Spring boot is a great and relatively a new project from Spring.io. The presentation discusses about basics of spring boot to advance topics. Sample demo apps are available here : https://github.com/bhagwat/spring-boot-samples
Spring Boot is a framework for creating stand-alone, production-grade Spring based applications that can be "just run". It takes an opinionated view of the Spring platform and third-party libraries so that new and existing Spring developers can quickly get started with minimal configuration. Spring Boot aims to get developers up and running as quickly as possible with features like embedded HTTP servers, automatic configuration, and opinions on structure and dependencies.
Spring Boot is a framework for creating stand-alone, production-grade Spring based applications that can be "just run". It aims to provide a radically faster and widely accessible starting experience for developing Spring applications. Spring Boot applications can be started using java -jar or traditional WAR deployments and require very little Spring configuration. The document then discusses system requirements, development environment, creating a simple Hello World application, using Spring Boot Admin to monitor applications, configuring databases, Spring Data JPA, REST controllers, caching with EhCache, building web applications with Thymeleaf, and project structure.
This document discusses Spring Boot and how it provides automatic configuration for common web application functionalities like JPA, security, and Spring MVC. It also covers how Spring Boot uses starter dependencies to select libraries automatically and provides tools like the CLI and Spring Initializr. The document then demonstrates creating a basic Spring Boot application and discusses testing Spring Boot applications using techniques like mocking Spring MVC and integrating tests.
The document discusses Spring Boot, a framework for creating stand-alone, production-grade Spring based applications. It describes how Spring Boot allows creating projects quickly with features like embedded servers and auto-configuration. It then covers how to develop a basic Spring Boot web application including creating the project structure with Maven, adding controllers and properties files, and connecting to databases using Spring Data. Overall, the document provides an overview of Spring Boot and guidance on starting a Spring Boot web application project.
Welcome to presentation on Spring boot which is really great and relatively a new project from Spring.io. Its aim is to simplify creating new spring framework based projects and unify their configurations by applying some conventions. This convention over configuration is already successfully applied in so called modern web based frameworks like Grails, Django, Play framework, Rails etc.
This talk introduces Spring's REST stack - Spring MVC, Spring HATEOAS, Spring Data REST, Spring Security OAuth and Spring Social - while refining an API to move higher up the Richardson maturity model
Spring Boot is a framework for creating stand-alone, production-grade Spring-based applications that can be started using java -jar without requiring any traditional application servers. It is designed to get developers up and running as quickly as possible with minimal configuration. Some key features of Spring Boot include automatic configuration, starter dependencies to simplify dependency management, embedded HTTP servers, security, metrics, health checks and externalized configuration. The document then provides examples of building a basic RESTful web service with Spring Boot using common HTTP methods like GET, POST, PUT, DELETE and handling requests and responses.
Spring Data is a high level SpringSource project whose purpose is to unify and ease the access to different kinds of persistence stores, both relational database systems and NoSQL data stores.
Introduction to the Spring Framework:
Generar description
IoC container
Dependency Injection
Beans scope and lifecycle
Autowiring
XML and annotation based configuration
Additional features
Spring Security is a powerful and highly customizable authentication and authorization framework for Spring-based applications. It provides authentication via mechanisms like username/password, LDAP, and SSO. Authorization can be implemented through voting-based access control or expression-based access control at the web (URL) level and method level. It includes filters, providers, and services to handle authentication, authorization, logout, and remember-me functionality. Configuration can be done through XML or Java configuration with support for common annotations.
This document discusses Spring Boot, an open source framework for building microservices and web applications. It provides scaffolding to help build Spring-based services more quickly. The author chose Spring Boot for a project because it integrates well with other frameworks like Jersey and allows building services quickly. Key Spring Boot components discussed include REST frameworks, embedded servers, logging frameworks, security, and metrics. The author outlines their Spring Boot stack and package structure. They discuss using Spring Data for persistence, Swagger for API documentation, and helper libraries like Lombok. The document also covers testing approaches using REST Assured and Spring Integration.
This document contains an agenda and slides for a presentation on Spring Boot. The presentation introduces Spring Boot, which allows developers to rapidly build production-grade Spring applications with minimal configuration. It demonstrates how to quickly create a "Hello World" application using Spring Boot and discusses some of the features it provides out-of-the-box like embedded servers and externalized configuration. The presentation also shows how to add additional functionality like Thymeleaf templates and actuator endpoints to monitor and manage applications.
This document provides information on using Spring Boot Actuator to add production-ready features like health monitoring, metrics collection, and auditing to Spring Boot applications. It describes built-in endpoints like /health and /metrics that provide health checks and application metrics. It also shows how to add custom health indicators, record custom metrics, and export metrics to external systems.
This is a basic tutorial on Spring core.
Best viewed when animations and transitions are supported, e.g., view in MS Powerpoint. So, please try to view it with animation else the main purpose of this presentation will be defeated.
Building a REST Service in minutes with Spring BootOmri Spector
Â
A walk through building a micro service using Spring Boot.
Deck presented at Java 2016
Source accompanying presentation can be found at https://github.com/ospector/sbdemo
This document provides an overview of developing a web application using Spring Boot that connects to a MySQL database. It discusses setting up the development environment, the benefits of Spring Boot, basic project structure, integrating Spring MVC and JPA/Hibernate for database access. Code examples and links are provided to help get started with a Spring Boot application that reads from a MySQL database and displays the employee data on a web page.
This document provides an overview of Spring MVC including:
- The MVC design pattern and how Spring MVC implements it with a front controller and other components.
- Configuring Spring MVC in a web application using XML or Java configuration.
- Defining controllers with annotations like @Controller and @RequestMapping and mapping requests to controller methods.
- Other Spring MVC concepts covered include the DispatcherServlet, handler mappings, view resolution, form handling, and validation.
NestJS (https://nestjs.com/) is a Node.js framework for building server-side applications. This slide give you a brief introduction of Nest, and shows the examples like Service, Middleware, and Pipe, etc.
Overview of Spring Boot for the rapid development of Java Applications and Microservices. More information can be found at : https://www.spiraltrain.nl/course-spring-boot-development/?lang=en
This document provides an overview of Spring Boot, including:
- Comparisons between Spring Boot, Spring, and Spring MVC.
- The advantages of Spring Boot like auto-configuration and ease of use.
- How to get started with Spring Boot using start.spring.io and key annotations.
- How Spring Boot handles dependencies, logging, exceptions, and databases.
- References additional resources on Spring Boot.
That old Spring magic has me in its SpELCraig Walls
Â
The document is a presentation on the Spring Expression Language (SpEL). It provides an overview of what SpEL is, how it can be used to configure beans and in programming, and demonstrations of essential SpEL features like literals, operators, and accessing object members. The presentation contains an agenda that covers introducing SpEL, using it, essentials, examples, and Q&A. It encourages downloading example code and dives into SpEL syntax and capabilities.
The document discusses modular Java and OSGi. It introduces OSGi as a modularity specification for Java that provides an intra-VM service-oriented architecture. OSGi addresses issues with modularity in Java by allowing modules, known as bundles, to be installed, started, stopped, updated, and uninstalled dynamically at runtime. This helps solve problems like JAR hell by allowing multiple versions of classes to exist simultaneously. The document provides an overview of OSGi concepts and some popular open source OSGi implementations.
- The document discusses various Java template engines that can be used on the JVM including Thymeleaf, Mustache, Jade, and Scalate.
- A benchmark project was created to test the performance of these template engines in a Spring MVC application that renders a list of presentations.
- The results showed that Thymeleaf used more memory and was slower than commonly used engines like Freemarker and Velocity. Mustache performed very well. Scalate was over 100 seconds slower due to its layout mechanism.
Slides from my talk introducing Spring Boot. Unfortunately, this talk is 90% live-coding, so I'll post the relevant video recording here when it's available.
Spring MVC est un framwork qui permet dâimplĂŠmenter des applications selon le design pattern MVC.
Ce n'est pas un framework ÊvÊnementiel comme pourraient l'être jsf, wicket, tapestry ou struts 2. Mais il possède de nombreux points
d'extensions et utilisÊ avec Spring Web Flow il devient un framework très puissant.
* JSP 1.0 a vĂ˝voj k modernĂm MVC frameworkĹŻm
* VysvÄtlenĂ MVC vzoru
* ZpracovĂĄnĂ poĹžadavkĹŻ Spring MVC
* ZĂĄkladnĂ konfigurace a ovlĂĄdĂĄnĂ Spring MVC
Building RESTful applications using Spring MVCIndicThreads
Â
REST is an alternate and simpler approach for implementing WebServices. It is based on the HTTP protocol and hence leverages a lot of existing infrastructures. It uses an uniform interface thus making it easy to build client applications. In this session we will look at the fundamental concepts behind REST (Resource, URI, Stateless Conversation ..) and how to apply it in the context of a real applcation. We will also discuss the pros & cons of RESTful vs Soap based webservices. We will discuss the design of RESTful application and then look at how to implement it using Spring MVC.
Spring Framework 4.0 is the latest generation of the popular open source framework for Enterprise Java developers, focusing on the future with support for Java SE 8 and Java EE 7. In this presentation core Spring committer Sam Brannen will provide attendees an overview of the new enterprise features in the framework as well as new programming models made possible with the adoption of JDK 8 language features and APIs.
Specifically, this talk will cover support for lambda expressions and method references against Spring callback interfaces, JSR-310 Date-Time value types for Spring data binding and formatting, Spring's new @Conditional mechanism for activation of bean definitions, and a new WebSocket endpoint model. The presentation also provides an overview of Spring 4.0's updated support for enterprise APIs such as JMS 2.0, JPA 2.1, Bean Validation 1.1, Servlet 3.1, and JCache. Last but not least, Sam will highlight some of the major themes for the upcoming Spring Framework 4.1 release such as support for JCache 1.0 annotations, annotation-driven JMS listeners, and testing improvements.
The document discusses building RESTful applications with Spring MVC. It covers the pillars of REST including resources, URIs, HTTP methods, and representations. It provides examples of modeling resources as controllers and mapping HTTP methods to controller actions. It also discusses content negotiation, supporting different data representations like JSON, XML and RSS using Spring views.
SOAP Web Services have a well established role in the enterprise, but aside from the many benefits of the WS-* standards, SOAP and XML also carry additional baggage for developers. Consequently, REST Web Services are gaining tremendous popularity within the developer community. This session will begin by comparing and contrasting the basic concepts of both SOAP and REST Web Services. Building on that foundation, Sam Brannen will show attendees how to implement SOAP-based applications using Spring-WS 2.0. He will then demonstrate how to build a similar REST-ful application using Spring MVC 3.0. The session will conclude with an in-depth look at both server-side and client-side development as well as efficient integration testing of Web Services using the Spring Framework.
Josh Long is a Spring Developer Advocate at Pivotal. He discusses various Spring and microservices related topics including:
- The single responsibility principle and how it relates to microservices and Unix tools.
- Exposing services simply using REST which has no strict rules but embraces HTTP verbs and status codes.
- The Richardson Maturity Model for grading APIs on their REST compliance from Level 0 to Level 3.
- Security topics like OAuth, SSL/TLS, and ensuring applications are production ready with monitoring and management.
A presentation on how to implement RESTful Web Services with Spring MVC. This slide covers how to identify resources, use HTTP verbs, implement representations, use cache and so on.
Shootout! Template engines for the JVMJeroen Reijn
Â
These slides were from my JFall 2013 presentation about new template engines for the JVM. During this presentation I gave a short introduction to new and interesting template engines and show how they compare to the more well known: JSP, Velocity and Freemarker.
This tutorial is about Spring Boot.
The tutorial includes an introduction to Spring Boot, key features of Spring Boot, prototyping using CLI, managing profiles aka environment in Grails, using GORM and using GSP. The tutorial begins with a section which is an introduction to Spring Boot. It includes an introduction to Spring Boot, the benefits of using Spring Boot.
Following is a features section which includes the key features of Spring Boot like embedded servers, security, metrics etc. Next is a section about prototyping. It includes prototyping using CLI, getting started, the things that happen during prototyping, starter POMs and a demo, building Gradle, using plugin and adding dependencies, and hot reloading.
Consecutively there is a section about managing profiles. It includes managing profiles aka managing environment in Grails like binding properties and its examples, using spring data to add dependency. Moreover, there's also a section which includes using GORM for next level persistence and also includes server side view template libraries like JSP, velocity, tiles, GSP etc.
The last section of this tutorial is about GSP. It includes using GSP with Spring Boot as it has limited tags, adds dependency and helps in packaging executable JAR and WAR files.
Spring Boot provides a quick way to create Spring applications with minimal configuration. It allows for rapid prototyping through the Spring CLI and provides starter dependencies to add common features easily. Spring Boot applications can be packaged as executable jars or wars and support multiple build systems including Gradle. It aims to make standing up production-ready Spring applications as simple as possible.
August 7th, I attended a meetup of GDG Beijing, and give a presentation:Android Gradle Build System-Overview.
Mainly cover build system background knowledge, source code, interesting part of code, writing a plugin.
A general- âpurpose build automation tool. It can automate building, testing, deployment, publishing, generate documentation etc.
Designed to take advantage of convention over configuration.
Combines the power and flexibility of Ant with the dependency management and
conventions of Maven into a more effective way to build.
Grunt helps front-end web developers automate common tasks such as: linting, testing, sass compilation, watching assets. Check basic features of node.js, npm and Grunt.
This document provides an overview of building applications with Spring Boot. It discusses key features such as creating stand-alone Spring applications without separate web servers, automatic Spring configuration, and getting started quickly with one Java file and a build script. Pros include faster deployments and no need for web.xml files. Cons can include custom configuration challenges and incompatibility with some legacy Spring projects. The document also demonstrates sample code and references Spring Initializr for project setups.
This document discusses and compares three popular JVM web frameworks: Grails, Spring Boot, and Ratpack. It provides an overview of common patterns in web frameworks and features of each framework. Code examples are shown to demonstrate creating projects and running basic applications with each framework. The document argues that Groovy scripts provide a way to deploy microservices using any of the frameworks with a single file.
Gradle is a general-purpose build automation tool. It combines the power and flexibility of Ant with the dependency management and conventions of Maven into a more effective way to build. Its powered by Groovy DSL. Presentation discusses what and why Gradle with demo for java, groovy, web, multi-project and grails projects.
Make Your Build Great Again (DroidConSF 2017)Jared Burrows
Â
Slow builds have been plaguing Android development since the very beginning, especially for large multi-dex projects. As libraries tend to grow in size and the more libraries an application consumes it will slow down the build, especially when an application goes over the mutli-dex limit. Libraries aren't the only thing that can slow down the build, adding many Gradle plugins and repositories can increase the time it takes to configure the Gradle build. This talk will be centered around how I was able to decrease Yammer for Android's Gradle build times by optimizing our use of the Android Gradle plugin and the Gradle setup of our multi-project build and will give several tools and tips on how to help you profile and decrease your build times as well.
Introduction to Spring Boot
Spring Boot is a framework designed to simplify the development of new Spring applications. Built on top of the Spring Framework, Spring Boot offers a streamlined way to create stand-alone, production-ready applications. It achieves this by providing a set of default configurations and eliminating the need for extensive boilerplate code, making it a popular choice among developers for its ease of use and rapid development capabilities.
Evolution of Spring Framework
The Spring Framework revolutionized Java enterprise application development by providing a comprehensive programming and configuration model for modern Java-based enterprise applications. However, the extensive configuration required by Spring could be cumbersome, especially for new developers. This led to the inception of Spring Boot, which aims to ease the process of setting up, configuring, and deploying Spring applications.
Core Features of Spring Boot
1. Auto-Configuration
One of the hallmark features of Spring Boot is its ability to automatically configure your application based on the dependencies you have included. For instance, if you have the spring-boot-starter-web dependency in your project, Spring Boot will auto-configure components like the DispatcherServlet, Jackson (for JSON processing), and an embedded web server (Tomcat by default).
This auto-configuration reduces the amount of boilerplate code and XML configurations, allowing developers to focus on writing business logic rather than spending time on configuration.
2. Standalone Applications
Spring Boot applications are typically packaged as JAR files that include an embedded web server. This means you can run your application simply by executing the java -jar command. This standalone nature simplifies deployment and makes it easy to create microservices and cloud-native applications.
3. Production-Ready Features
Spring Boot includes several features that make it easier to manage and monitor applications in a production environment. These features include:
Health Checks: The /actuator/health endpoint provides information about the application's health status.
Metrics: The /actuator/metrics endpoint exposes various metrics related to the application's performance and resource utilization.
Externalized Configuration: Allows you to configure your application using properties files, YAML files, environment variables, and command-line arguments.
4. Spring Boot Starter POMs
Spring Boot simplifies dependency management by providing starter POMs. These are dependency descriptors that aggregate commonly used dependencies into a single, easy-to-include package. For example, the spring-boot-starter-web starter includes dependencies for Spring MVC, Jackson, and an embedded web server.
5. Spring Boot CLI
The Spring Boot CLI is a command-line tool that can be used to run Groovy scripts. This makes it easy to create prototypes and simple applications quickly. The CLI supports the same auto-configMM
Building a Spring Boot Application - Ask the Audience! (from JavaLand 2017)đ¤ Hanno Embregts đ¸
Â
Spring Boot makes it easy to create stand-alone Spring-based application that you can 'just run'. It uses a 'convention over configuration' approach to get you up and running in no-time, while offering all Spring features that you have grown fond of in the past years. In this session this is demonstrated by live-coding a Spring Boot application that will Âjust workÂ.
But audience beware, this is not your standard Âlive-coding session'. Attendees will have a vital say in the session's content by defining the applicationÂs requ irements. Should it be an app to track your kitchen cupboard contents or do you want a simple task planner? It's up to you! Should it use MongoDB or Couchbase? You decide! Do you want an AngularJS front-end with a RESTful backend or do you prefer a classic web app with Thymeleaf templates? It's your call! Seriously.
During the session you get to make these decisions by participating in an online vote. And you will discover that Spring Boot is up to the task no matter what choices you make.
So what are you waiting for? Bring your own device, help shape the application that we're building and learn lots about Spring Boot in the process.
This session is intended for Java software engineers with an interest in Spring Boot. Some Spring experience could come in handy, but is not strictly necessary. After this session, you will know enough to start your own Spring Boot project.
This document summarizes a presentation about SpringBoot, a framework for creating Spring applications. It discusses how SpringBoot uses Groovy and removes the need for XML configuration. It provides an overview of Texas NIC where the presenter works and some of their applications. It then discusses why SpringBoot was created, how it can be used with Groovy, and demonstrates some sample applications. It also covers some good aspects of SpringBoot, things that can be confusing, and unexpected behaviors. It concludes with some tips for using SpringBoot with IntelliJ IDEA.
This document provides an overview of the Globus project, which aims to develop a service that digitizes POD (Product, Organization, and Delivery) frameworks. It outlines topics to be covered such as development environment, server-side development, and testing. It describes setting up the development environment in IntelliJet IDEA and SBT. It also details next steps such as creating a project structure in SBT, using appropriate Scala constructs to build the model, integrating with Travis CI for continuous integration, defining the business logic layer in collaboration with teammates, and writing the business logic in Scala.
Improving build solutions dependency management with webpackNodeXperts
Â
Webpack is a build tool that bundles assets including JavaScript, images, fonts and CSS into packages called bundles that can be consumed in the browser. It analyzes dependencies between files and packages them accordingly. The webpack configuration file specifies the entry point, output, loaders and plugins. Loaders transform files and plugins add functionality to bundles. Webpack differs from other build tools like Grunt and Gulp in that it generates dependency graphs to bundle assets optimally rather than just running predefined tasks.
Building a Spring Boot Application - Ask the Audience! (from JVMCon 2018)đ¤ Hanno Embregts đ¸
Â
Spring Boot is a framework for creating stand-alone, production-grade Spring based applications that can be "run" using java -jar without the need for an external web server. It favors convention over configuration and aims to get developers up and running quickly with minimal configuration. Key features include an embedded web server, automatic configuration, and starters that provide prepackaged dependencies. Pros include faster development and deployment, while potential cons include more complex custom configuration and incompatibility with some legacy Spring projects. The documentation provides guidance on creating starter projects with an initial Java file, build script, and dependencies.
Pre-render Blazor WebAssembly on static web hosting at publishing timeJun-ichi Sakamoto
Â
This slide explains how to prerendering a Blazor WebAssembly app hosted on the static web hosting and save them to static HTML files at publishing time.
In this session, Markus will explain how to build OpenCms with Gradle from Source.
He will explain the benefits and advantages as well as the difficulties in building OpenCms with Gradle. Markus will show how to build and import OpenCms modules with Gradle. This includes creating an OpenCms module automatically from source out of the repository (Nexus).
Markus will also talk about:
- Continuous Developement with OpenCms
- Building an OpenCms .war file with external configuration
Eclipse Buildship allows Gradle projects to be imported and worked with in Eclipse. It provides features like running Gradle tasks in Eclipse, visualizing task execution, and creating new Gradle projects from templates. Future plans include improving views for tasks, plugins, and components as well as adding debug configuration support. Buildship is open source and contributions are welcome.
This document provides an overview of the Grails framework. It discusses Grails' features such as convention over configuration, scaffolding, REST support, and plugins. It also covers installing Grails, creating and running applications, testing, deployment, and basic configuration. Grails uses conventions for file and application structure and supports configuration for different environments.
Principles of Roods Approach!!!!!!!.pptxibtesaam huma
Â
Principles of Roodâs Approach
Treatment technique used in physiotherapy for neurological patients which aids them to recover and improve quality of life
Facilitatory techniques
Inhibitory techniques
ďˇ Integrated Marketing Communications (IMC)- Concept, Features, Elements, Role of advertising in IMC
ďˇ Advertising: Concept, Features, Evolution of Advertising, Active Participants, Benefits of advertising to Business firms and consumers.
ďˇ Classification of advertising: Geographic, Media, Target audience and Functions.
The Value of Time ~ A Story to Ponder On (Eng. & Chi.).pptxOH TEIK BIN
Â
A PowerPoint presentation on the importance of time management based on a meaningful story to ponder on. The texts are in English and Chinese.
For the Video (texts in English and Chinese) with audio narration and explanation in English, please check out the Link:
https://www.youtube.com/watch?v=lUtjLnxEBKo
Views in Odoo - Advanced Views - Pivot View in Odoo 17Celine George
Â
In Odoo, the pivot view is a graphical representation of data that allows users to analyze and summarize large datasets quickly. It's a powerful tool for generating insights from your business data.
The pivot view in Odoo is a valuable tool for analyzing and summarizing large datasets, helping you gain insights into your business operations.
Front Desk Management in the Odoo 17 ERPCeline George
Â
Front desk officers are responsible for taking care of guests and customers. Their work mainly involves interacting with customers and business partners, either in person or through phone calls.
Slide Presentation from a Doctoral Virtual Open House presented on June 30, 2024 by staff and faculty of Capitol Technology University
Covers degrees offered, program details, tuition, financial aid and the application process.
AI Risk Management: ISO/IEC 42001, the EU AI Act, and ISO/IEC 23894PECB
Â
As artificial intelligence continues to evolve, understanding the complexities and regulations regarding AI risk management is more crucial than ever.
Amongst others, the webinar covers:
⢠ISO/IEC 42001 standard, which provides guidelines for establishing, implementing, maintaining, and continually improving AI management systems within organizations
⢠insights into the European Union's landmark legislative proposal aimed at regulating AI
⢠framework and methodologies prescribed by ISO/IEC 23894 for identifying, assessing, and mitigating risks associated with AI systems
Presenters:
Miriama Podskubova - Attorney at Law
Miriama is a seasoned lawyer with over a decade of experience. She specializes in commercial law, focusing on transactions, venture capital investments, IT, digital law, and cybersecurity, areas she was drawn to through her legal practice. Alongside preparing contract and project documentation, she ensures the correct interpretation and application of European legal regulations in these fields. Beyond client projects, she frequently speaks at conferences on cybersecurity, online privacy protection, and the increasingly pertinent topic of AI regulation. As a registered advocate of Slovak bar, certified data privacy professional in the European Union (CIPP/e) and a member of the international association ELA, she helps both tech-focused startups and entrepreneurs, as well as international chains, to properly set up their business operations.
Callum Wright - Founder and Lead Consultant Founder and Lead Consultant
Callum Wright is a seasoned cybersecurity, privacy and AI governance expert. With over a decade of experience, he has dedicated his career to protecting digital assets, ensuring data privacy, and establishing ethical AI governance frameworks. His diverse background includes significant roles in security architecture, AI governance, risk consulting, and privacy management across various industries, thorough testing, and successful implementation, he has consistently delivered exceptional results.
Throughout his career, he has taken on multifaceted roles, from leading technical project management teams to owning solutions that drive operational excellence. His conscientious and proactive approach is unwavering, whether he is working independently or collaboratively within a team. His ability to connect with colleagues on a personal level underscores his commitment to fostering a harmonious and productive workplace environment.
Date: June 26, 2024
Tags: ISO/IEC 42001, Artificial Intelligence, EU AI Act, ISO/IEC 23894
-------------------------------------------------------------------------------
Find out more about ISO training and certification services
Training: ISO/IEC 42001 Artificial Intelligence Management System - EN | PECB
Webinars: https://pecb.com/webinars
Article: https://pecb.com/article
-------------------------------------------------------------------------------
How to Configure Time Off Types in Odoo 17Celine George
Â
Now we can take look into how to configure time off types in odoo 17 through this slide. Time-off types are used to grant or request different types of leave. Only then the authorities will have a clear view or a clear understanding of what kind of leave the employee is taking.
How to Show Sample Data in Tree and Kanban View in Odoo 17Celine George
Â
In Odoo 17, sample data serves as a valuable resource for users seeking to familiarize themselves with the functionalities and capabilities of the software prior to integrating their own information. In this slide we are going to discuss about how to show sample data to a tree view and a kanban view.
2. Agenda
⢠What
and
Why?
⢠Key
features
of
Spring
boot
⢠Prototyping
using
CLI.
⢠Gradle
primer
⢠Managing
profiles
aka
environment
in
grails
⢠Using
Spring
data
libraries
e.g.
MongoDB
⢠Using
GORM
⢠Presentation
layer
⢠Using
GSP
2
3. What
and
why?
⢠Its
not
a
replacement
for
Spring
framework
but
it
presents
a
small
surface
area
for
users
to
approach
and
extract
value
from
the
rest
of
Spring.
⢠Spring-Ââboot
provides
a
quick
way
to
create
a
Spring
based
application
from
dependency
management
to
convention
over
configuration.
⢠Grails
3.0
will
be
based
on
Spring
Boot.
image
source
:
http://spring.io/blog/2013/08/06/spring-Ââboot-Ââsimplifying-Ââspring-Ââfor-Ââeveryone
3
4. Key
Features
⢠Stand-Ââalone
Spring
applications
⢠No
code
generation/
No
XML
Config
⢠Automatic
configuration
by
creating
sensible
defaults
⢠Starter
dependencies
⢠Structure
your
code
as
you
like
⢠Supports
Gradle
and
Maven
⢠Common
non-Ââfunctional
requirements
for
a
"real"
application
â
embedded
servers,
â
security,
metrics,
health
checks
â
externalised
configuration
5. Rapid
Prototyping
:
Spring
CLI
⢠Quickest
way
to
get
a
spring
app
off
the
ground
⢠Allows
you
to
run
groovy
scripts
without
much
boilerplate
code
⢠Not
recommended
for
production
Install using GVM
$ gvm install springboot
Running groovy scripts
$ spring run app.groovy
$ spring run --watch app.groovy
$ spring test tests.groovy
6. A
quick
web
application
using
spring
boot
app.groovy
@Controller
class
Example
{
@RequestMapping("/")
@ResponseBody
public
String
helloWorld()
{
"Hello
Spring
boot
audience!!!"
}
}
$
spring
run
app.groovy
7. What
Just
happened?
//
import
org.springframework.web.bind.annotation.Controller
//
other
imports
...
//
@Grab("org.springframework.boot:spring-Ââboot-Ââweb-Ââstarter:0.5.0")
//
@EnableAutoConfiguration
@Controller
class
Example
{
@RequestMapping("/")
@ResponseBody
public
String
hello()
{
return
"Hello
World!";
}
//
public
static
void
main(String[]
args)
{
//
SpringApplication.run(Example.class,
args);
//
}
}
8. Starter
POMs
⢠One-Ââstop-Ââshop
for
all
the
Spring
and
related
technology
⢠A
set
of
convenient
dependency
descriptors
⢠Contain
a
lot
of
the
dependencies
that
you
need
to
get
a
project
up
and
running
quickly
⢠All
starters
follow
a
similar
naming
pattern;
â
spring-Ââboot-Ââstarter-Ââ*
⢠Examples
â spring-Ââboot-Ââstarter-Ââweb
â spring-Ââboot-Ââstarter-Ââdata-Âârest
â spring-Ââboot-Ââstarter-Ââsecurity
â spring-Ââboot-Ââstarter-Ââamqp
â spring-Ââboot-Ââstarter-Ââdata-Ââjpa
â spring-Ââboot-Ââstarter-Ââdata-Ââelasticsearch
â spring-Ââboot-Ââstarter-Ââdata-Ââmongodb
â spring-Ââboot-Ââstarter-Ââactuator
9. Demo
:
Starter
POMs
@Grab('spring-Ââboot-Ââstarter-Ââsecurity')
@Grab('spring-Ââboot-Ââstarter-Ââactuator')
@Controller
class
Example
{
@RequestMapping("/")
@ResponseBody
public
String
helloWorld()
{
return
"Hello
Audience!!!"
}
}
//security.user.name
:
default
'user'
//security.user.password
:
see
log
for
auto
generated
password
//actuator
endpoints:
/beans,
/health,
/mappings,
/metrics
etc.
16. Binding
properties
16
Using
ConfigurationProperties
annotation
import
org.springframework.boot.context.properties.ConfigurationProperties
import
org.springframework.stereotype.Component
@Component
@ConfigurationProperties(prefix
=
"app")
class
AppInfo
{
String
name
String
version
}
Using
Value
annotation
import
org.springframework.beans.factory.annotation.Value
import
org.springframework.stereotype.Component
@Component
class
AppConfig
{
@Value('${app.name}')
String
appName
@Value('${server.port}')
Integer
port
}
17. Examples
17
OS
env
variable
export
SPRING_PROFILES_ACTIVE=development
export
SERVER_PORT=8090
gradle
bootRun
java
-Ââjar
build/libs/demo-Ââ1.0.0.jar
with
a
-ÂâD
argument
(remember
to
put
it
before
the
main
class
or
jar
archive)
java
-Ââjar
-ÂâDspring.profiles.active=development
build/libs/dem-Ââ1.0.0.jar
java
-Ââjar
-ÂâDserver.port=8090
build./libs/demo-Ââ1.0.0.jar
18. Using
Spring
data
⢠Add
dependency
compile
'org.springframework.boot:spring-Ââboot-Ââstarter-Ââdata-Ââmongodb'
⢠Configure
database
URL
spring.data.mongodb.uri=mongodb://localhost/springtestdev
⢠Add
entity
class
import
org.springframework.data.annotation.Id;
class
⢠Add
Person{@Id
String
id,
String
name}
repository
interface
import
org.springframework.data.mongodb.repository.MongoRepository
public
interface
PersonRepository
extends
⢠Autowire
and
use
like
charm
MongoRepository<Person,
String>
{}
@Autowired
PersonRepository
personRepository
personRepository.save(new
Person(name:'Spring
Boot'))
personRepository.findAll()
personRepository.count()
19. Next
level
persistence
with
GORM
⢠Add
dependencies
to
use
GORM-ÂâHibernate
⢠For
GORM
MongoDB
use
the
following
dependencies
compile
'org.grails:gorm-Ââmongodb-Ââspring-Ââboot:1.1.0.RELEASE'
⢠Add
entity
with
@grails.persistence.entity
19
compile
'org.springframework.boot:spring-Ââboot-Ââstarter-Ââdata-Ââjpa'
compile
'org.grails:gorm-Ââhibernate4-Ââspring-Ââboot:1.1.0.RELEASE'
runtime
'com.h2database:h2'
//for
h2
database
import
grails.persistence.Entity
@Entity
class
Person
{
String
name;
Integer
age
static
constraints
=
{
name
blank:
false
age
min:
15
}
}
Further
reading
https://github.com/grails/grails-Ââdata-Ââmapping
21. ⢠Very
limited
existing
tags
available
⢠https://github.com/grails/grails-Ââboot/issues/3
⢠Add
dependency
⢠Put
GSP
templates
in
resources/templates
folder
GSP
21
compile
"org.grails:grails-Ââgsp-Ââspring-Ââboot:1.0.0.RC1"
compile
"org.grails:grails-Ââweb:2.4.0.M2"
22. GSP
continued...
⢠Sample
request
handler
22
@RequestMapping("/show/{id}")
public
ModelAndView
show(@PathVariable
Long
id)
{
Person
person
=
Person.read(id)
if
(person)
{
//render(view:"/person/show",
model:[personInstance:personInstance])
new
ModelAndView("/person/show",
[personInstance:
Person.get(id)])
}
else
{
log.info
"No
entity
fount
for
id
:
"
+
id
//redirect(controller:"person",
action:"list")
new
ModelAndView("redirect:/person/list")
}
}
24. Packaging
executable
jar
and
war
files
24
Packaging
as
jar
with
embedded
tomcat
$
gradle
build
$
java
-Ââjar
build/libs/mymodule-Ââ0.0.1-ÂâSNAPSHOT.jar
Packaging
as
war
:
configure
build.groovy
//...
apply
plugin:
'war'
war
{
baseName
=
'myapp'
version
=
'0.5.0'
}
//....
configurations
{
providedRuntime
}
dependencies
{
compile("org.springframework.boot:spring-Ââboot-Ââstarter-Ââweb")
providedRuntime("org.springframework.boot:spring-Ââboot-Ââstarter-Ââtomcat")
//
...
}
$
gradle
war