During the exam task you are going to take template of the multimodule project - online shop, and integrate Spring Data JPA into the persistence module of the application.
Exam Task - https://docs.google.com/document/d/16Gx8rIHynGErVA5iSfmV7xLJ7VHKmWwKsCKbDIu3g6A/edit?usp=sharing
During the exam task you are going to take a template of the multimodule project - online shop, and integrate Spring JDBC into the persistence module of the application.
Exam Task - https://docs.google.com/document/d/1hUrihSGAdMao8_xp6IKkzniD7NdAzVyq5fmas1PyvJg/edit?usp=sharing
Hello team,
If you read this exam task this means that you completed Spring Framework section and has significant experience in Java. And that’s why, this exam task wouldn’t be the regular one like you had previously in the course.
This exam task will be super close to your future job and real work environment. Just imagine that you are given task at your job, and you have nothing else to do but implement it. Very oftne at your job you will hear words that you don’t know what are they about - you need to google them. Where often you would deal with things that you don’t know how to deal with - you need to google again and find answers. The thing is, that in real life, you don’t always have the API that you worked with before. And usually, each new task - it is a new research.
So, with this exam task I want you to challenge yourself. With this task you need to prove yourself that you are not simply good in Java, Spring, or anything else. Completion of this task will mean that you are true Software Engineer. Because today, in most companies, it is not enough just to know Java. It is important how fast you can learn new things. And understanding the core principles of web development will help you to learn new things faster.
That’s why be prepared that for completion of this exam task you would need to make your own research on external API. Of course, I will provide you with the detailed review of solution. But it is better you implemented the solution on your own, and only then you would check my solution. So, let me jump to the task description.
Video of the application that you need to develop - https://youtu.be/W4vBlMhelVE
The description of the app from the video is below.
You need to create web application, that would handle “onMention” events from Slack messenger. On “onMention” event, web app should use GPT Capabilities to process the request. This may include the following behavior:
Integration with ChatGPT and sending the response to the end user from the ChatGPT
Invocation of required functions to get necessary data, and then pass it to the ChatGPT with original request to analyze data and provide end-user with the answer.
Like it is shown in the video you need to use Slack messenger interface in order to submit requests to our web application. The end user expects to get relevant answers and behavior for such scenarios:
Analysis of Data from Jira:
how many work items do we have in Jira?
how many work items <USER NAME> has assigned now in Jira?
how many work items with the type “bug” we have now in not completed status?
can you group these bugs by status, please?
check, please, due dates of not completed bugs that you referred to, and tell me, when is the latest due date?
and who is the bug with the latest due date assigned to?
can you remind me of the issue ID, please, in the scope of which we planned to implement a persistent cart state across multiple browsers for the same account?
can you group all items from Jira by assignee, please?
can you group all items by issue type, please?
can you create a story in Jira about <USER STORY DESCRIPTION>, assign it to <USER NAME> and set due date <DUE DATE>
Other scenario to implement:
Generate and send email from the Slack interface with the help of Chat GPT
The repository with the solution - https://github.com/AndriiPiatakha/openai-learnit
If you want to hear explanation of each line from the solution, please, continue watching the course, namely the sections:
OpenAI API
Slack API
Jira API
ChatGPT API
Inside the lessons we develop the application using the requirements shared above.
EXPLAIN THE DI AND IOC PATTERN.
Dependency injection (DI) is a design pattern and architectural model also known as Inversion of Control (IoC). DI describes the situation when one object implements its functionality through another object. For example, a database connection is passed to the object's constructor as an argument, instead of the constructor itself establishing the connection. There are three forms of dependency injection: setter, constructor, and interface injection.
DI is a way to achieve loose coupling. IoC provides the ability for an object to obtain references to its dependencies. This is usually implemented through the lookup method. The advantage of IoC is that this model allows you to separate objects from the implementation of the mechanisms that it uses. As a result, we gain greater flexibility in both application development and application testing.
WHAT ARE THE BENEFITS OF DEPENDENCY INJECTION (DI)?
The benefits of DI include:
Reducing the amount of glue code. One of the biggest benefits of DI is the ability to greatly reduce the amount of code that must be written to tie together the various components of an application. Often this code is very simple - when you create a dependency, a new instance of the corresponding object must be created.
Simplified application configuration. By using DI, the process of configuring an application is greatly simplified. Annotations or XML files can be used to configure classes that can be injected into other classes.
Ability to manage common dependencies in a single repository. With the traditional approach of managing dependencies in shared services, such as data source connection, transaction, remote services, etc., you instantiate (or get them from defined factory classes) the dependencies where they are needed - inside the dependent class. This causes dependencies to be propagated across many classes in the application, which can make them difficult to change. In the case of using DI, all information about common dependencies is contained in a single repository (Spring has the ability to store this information in XML files or Java classes).
Improved testing capability. When classes are designed for DI, it becomes possible to easily replace dependencies. This is especially useful when testing an application.
Stimulation of quality design solutions for applications. Generally speaking, designing for DI means designing with interfaces. With Spring, you have a range of DI tools at your disposal and can focus on building the application logic rather than on a DI-enabled platform.
WHICH IOC CONTAINERS DO YOU KNOW?
Spring is an IoC container. In addition to it, there are HiveMind, Avalon, PicoContainer, etc.
HOW IS DI IMPLEMENTED IN SPRING FRAMEWORK?
The implementation of DI in Spring is based on two key Java concepts - JavaBeans and interfaces. When using Spring as a DI provider, you have the flexibility to define dependency configuration within your applications in a variety of ways (i.e. externally in XML files, via Spring's Java configuration classes, or via Java annotations in your code). JavaBeans (also called POJOs (Plain Old Java Objects)) provide a standard mechanism for creating Java resources that are configurable in a variety of ways. Through the use of DI, the amount of code that is required when designing an application based on interfaces is reduced to almost zero. Also, interfaces are the best way to get the most out of DI because beans can use any implementation of an interface to satisfy their dependency.
WHAT IS SPRING? WHAT PARTS IS THE SPRING FRAMEWORK COMPOSED OF?
Spring is an open source framework designed to simplify the development of enterprise applications. One of the main advantages of Spring is its layered architecture, which allows you to define which components will be used in your application. Spring modules are built around a core container that defines the creation, configuration, and management of beans.
Main modules are:
Main Container - Provides the core functionality of Spring. The main component of a container is the BeanFactory, an implementation of the Factory pattern. BeanFactory allows you to separate application configuration and dependency information from code.
Spring context is a configuration file that provides environment information for Spring. This includes enterprise services such as JNDI, EJB, internationalization, validation, and so on.
Spring AOP - responsible for integrating aspect-oriented programming into the framework. Spring AOP provides a transaction management service for a Spring application.
Spring DAO - The abstract layer of Spring JDBC DAO provides an exception hierarchy and many error messages for different DBs. This hierarchy simplifies exception handling and greatly reduces the amount of code you would need to write for operations such as opening and closing a connection.
Spring ORM - Responsible for integrating Spring and popular ORM frameworks such as Hibernate, iBatis, and JDO.
Spring Web module - classes that help simplify Web development (authorization, access to Spring beans from the web).
Spring MVC framework is an implementation of the MVC pattern for building Web applications.
NAME SOME OF THE DESIGN PATTERNS USED IN THE SPRING FRAMEWORK?
The Spring Framework uses many design patterns, for example:
Singleton Pattern: Creating beans with default scope.
Factory Pattern: Bean Factory classes
Prototype Pattern: Bean scopes
Adapter Pattern: Spring Web and Spring MVC
Proxy Pattern: Spring Aspect Oriented Programming support
Template Method Pattern: JdbcTemplate, HibernateTemplate etc
Front Controller: Spring MVC DispatcherServlet
Data Access Object: Spring DAO support
Dependency Injection and Aspect Oriented Programming
etc.
WHAT ARE SOME OF THE IMPORTANT FEATURES AND BENEFITS OF THE SPRING FRAMEWORK?
The Spring Framework provides solutions to many of the challenges faced by Java developers and organizations that want to build an information system based on the Java platform. Due to the wide functionality, it is difficult to determine the most significant structural elements of which it consists. The Spring Framework is not entirely tied to the Java Enterprise platform, despite its extensive integration with it, which is an important reason for its popularity.
Relative ease in learning and using the framework in developing and maintaining an application.
Dependency Injection (DI) and Inversion of Control (IoC) allow you to write components that are independent of each other, which gives advantages in team development, module portability, etc.
The Spring IoC container manages the life cycle of a Spring Bean and is configured like a JNDI lookup.
The Spring project contains many sub-projects that cover important parts of software development such as web services, web programming, working with databases, loading files, error handling, and more. All this is configured in a single format and simplifies application support.
WHAT ARE THE BENEFITS OF USING THE SPRING TOOL SUITE?
To simplify the process of developing Spring-based applications in Eclipse (the most commonly used IDE for developing Java applications), the Spring IDE project has been created within Spring. The project is free. It is integrated into Eclipse IDE, Spring IDE, Mylyn (task based development environment in Eclipse), Maven for Eclipse, AspectJ Development Tool.
WHAT IS AOP? HOW DOES THIS RELATE TO IOC?
Aspect-Oriented Programming (AOP) is a programming paradigm based on the idea of separation of functionality in order to better break down a program into modules. AOP and Spring are complementary technologies that allow you to solve complex problems by separating functionality into separate modules. AOP provides the ability to implement end-to-end logic - i.e. logic that applies to many parts of the application in one place and ensure that this logic is automatically applied throughout the application. Spring's approach to AOP is to create "dynamic proxies" for the target objects and "attach" the objects to a configured “advice” to perform pass-through logic.
WHAT ARE ASPECT, ADVICE, POINTCUT, JOINTPOINT AND ADVICE ARGUMENTS IN AOP?
Basic concepts of AOP:
Aspect is a module or class that implements end-to-end functionality. The aspect modifies the behavior of the rest of the code by applying the hint at join points defined by some slice.
Advice is a piece of code that must be executed on a single connection point. There are several types of advices, the advice can be executed before, after or instead of the join point.
A joinpoint is a well-defined point in a running program where advice should be applied. Common examples of joinpoints include method invocation, class initialization, and object instantiation. Many AOP implementations allow you to use method calls and object field accesses as join points.
Pointcut - a set of connection points. The slice determines whether a given connection point matches a given advice. The most convenient implementations of AOP use the syntax of the host language to define slices (for example, AspectJ uses Java signatures) and allow them to be reused through renaming and combining.
Weaving is the process of actually inserting aspects at a specific point in the application code. For compile-time AOP solutions, this is done at compile time, usually as an additional step in the build process. Similarly, for runtime AOP solutions, the binding happens dynamically at runtime. AspectJ supports another binding mechanism called load-time weaving (LTW), which intercepts the underlying JVM classloader and provides binding to the bytecode when it is loaded by the classloader.
A target is an object whose execution flow is modified by some AOP process. The target object is often referred to as a advice-equipped object.
Introduction - is a process by which you can change the structure of an object by introducing additional methods or fields into it, changing the inheritance hierarchy to add aspect functionality to foreign code. Usually implemented using some metaobject protocol (MOP).
WHAT IS THE DIFFERENCE BETWEEN SPRING AOP AND ASPECTJ AOP?
AspectJ is the de facto standard for implementing AOP. Spring's implementation of AOP has some differences:
Spring AOP is a bit simpler because there is no need to monitor the linking process.
Spring AOP supports AspectJ annotations, so we can work in a spring project in a similar way to an AspectJ project.
Spring AOP only supports proxy-based AOP and can only use one type of join point - Method Invocation. AspectJ supports all kinds of join points.
The disadvantage of Spring AOP is that it only works with its own beans that exist in the Spring Context.
WHAT IS IOC SPRING CONTAINER?
At its core, IoC, and therefore DI, aims to offer a simple mechanism for exposing component dependencies (often referred to as object collaborators) and managing those dependencies throughout their lifecycle. A component that requires certain dependencies is often referred to as a dependent object or, in the case of IoC, a target object. IoC provides services through which components can access their dependencies and services for interacting with dependencies during their lifetime. In general, IoC can be split into two subtypes: Dependency Injection and Dependency Lookup.
Inversion of control is a big part of what Spring does, and the core implementation of Spring is based on inversion of control, although Dependency Lookup facilities are also provided. When the Spring framework automatically provides collaborators to a dependent object, it does so using Inversion of Control (Dependency Injection). In a Spring-based application, it is always preferable to use Dependency Injection to pass collaborators to dependent objects instead of forcing dependent objects to get collaborators via lookup.
WHAT IS A SPRING BIN?
The term bean is used in Spring to refer to any bean managed by a container. Usually, beans adhere to the JavaBean specification at some level, but this is not necessary, especially if you plan to use Constructor Injection to bind the beans to each other. The ApplicationContext is used to get the bean instance. The IoC container manages the spring bean's life cycle, scope, and injection.
WHY THE SPRING BEAN CONFIGURATION FILE IS IMPORTANT?
The spring configuration file defines all the beans that will be initialized in the Spring Context. When an instance of the Spring ApplicationContext is created, the configuration xml file will be read and the necessary initializations specified in it will be performed. Apart from the basic configuration, the file may contain descriptions of interceptors, view resolvers, localization settings, etc.
WHICH SPRING BEAN SCOPES DO YOU KNOW?
singleton (default) - Single bean instance per Spring IoC container.
prototype - A new bean instance is created every time a bean is requested.
request - Only a single instance will be created and available during the complete lifecycle of an HTTP request. Only valid in the context of a web-aware Spring ApplicationContext.
session - Only a single instance will be created and available during the complete lifecycle of an HTTP Session. Only valid in the context of a web-aware Spring ApplicationContext.
application - Only a single instance will be created and available during the complete lifecycle of ServletContext. Only valid in the context of a web-aware Spring ApplicationContext.
websocket - Only a single instance will be created and available during the complete lifecycle of WebSocket. Only valid in the context of a web-aware Spring ApplicationContext.
WHAT IS THE LIFE CYCLE OF A SPRING BEAN?
The life cycle of a Spring bean is the lifetime of a object. Spring beans are initialized when the Spring container is initialized and all dependencies are injected. When the container is destroyed, the entire contents are destroyed as well. If we need to set some action when initializing and destroying the bean, then we need to use the init () and destroy () methods. You can use the @PostConstruct and @PreDestroy() annotations for this. Or xml configuration.
EXPLAIN BEANFACTORY IN SPRING.
BeanFactory is an implementation of the Factory pattern, its functionality covers the creation of beans. Because this factory knows a lot about the application's objects, it can create relationships between objects during the instantiation phase. There are several BeanFactory implementations, the most commonly used is
"org.springframework.beans.factory.xml.XmlBeanFactory". It loads beans based on an XML configuration file. To create an XmlBeanFactory pass an InputStream to the constructor, InputStream with XML file configuration
After this, the factory knows about the beans, but their instances have not yet been created. To instantiate a bean, you need to call the getBean() method.
HOW TO GET SERVLETCONTEXT AND SERVLETCONFIG OBJECTS INSIDE SPRING BEAN?
There are two ways to get the main container objects inside a bean:
Implement one of the Spring*Aware (ApplicationContextAware, ServletContextAware, ServletConfigAware, etc.) interfaces.
Use @Autowired in the class to inject ServletContext
WHAT IS THE ROLE OF APPLICATIONCONTEXT IN SPRING?
While BeanFactory is used in simple applications, Application Context is a more complex container. Like BeanFactory it can be used to load and bind beans, but it also provides:
the ability to receive text messages, including support for internationalization;
general mechanism for working with resources;
events for beans that are registered as listeners.
Due to more functionality, it is recommended to use Application Context instead of BeanFactory. The latter is used only in cases where resources are scarce, such as when developing for mobile devices.
WHAT IS BINDING IN SPRING AND TELL ABOUT THE @AUTOWIRED ANNOTATION?
The process of injecting dependencies into beans during initialization is called Spring Bean Wiring. It's considered good practice to explicitly wire dependencies, but Spring provides an additional @Autowired binding mechanism. An annotation can be used on a field or method to bind by type. For the annotation to work, you need to specify small settings in the spring configuration file using the context:annotation-config element.
WHAT ARE THE DIFFERENT TYPES OF AUTO WIRING IN SPRING?
There are four types of binding in a spring:
autowire byName,
autowire byType,
autowire by constructor,
autowiring by @Autowired and @Qualifier annotations
GIVE AN EXAMPLE OF FREQUENTLY USED SPRING ANOTATIONS.
@Controller is a front controller class in a Spring MVC project.
@RequestMapping - allows you to set the URI mapping template in the controller handler method.
@ResponseBody - allows you to send an Object in the response. Typically used to send XML or JSON data.
@PathVariable - Specifies the dynamic mapping of values from the URI inside the handler method arguments.
@Autowired - Used to automatically wire dependencies in spring beans.
@Qualifier - used in conjunction with @Autowired to qualify the binding data when collisions are possible (e.g. identical names/types).
@Service - indicates that the class implements service functions.
@Scope - Specifies the scope of a spring bean.
@Configuration, @ComponentScan and @Bean - for java based configurations.
AspectJ annotations to customize aspects and advices, @Aspect, @Before, @After, @Around, @Pointcut, etc.
CAN WE SEND AN OBJECT AS A RESPONSE TO A CONTROLLER HANDLER METHOD?
Yes it is possible. For this, the @ResponseBody annotation is used. This is how you can send responses in the form of JSON, XML in restful web services.
IS SPRING BEAN THREAD SAFE?
By default, the bean is set as a singleton in Spring. Thus, all public variables of a class can be changed simultaneously from different places. So - no, it is not. However, by changing the scope of the bean to request, prototype, session, it will become thread-safe, but this will affect performance.
HOW TO CREATE AN APPLICATIONCONTEXT IN A JAVA PROGRAM?
In a standalone Java program, an ApplicationContext can be created like this:
AnnotationConfigApplicationContext - When using Spring as a standalone application, you can create an initialize container using annotations.
ClassPathXmlApplicationContext - Gets information from an xml file located on the classpath.
FileSystemXmlApplicationContext - receives information from an xml file, but with the ability to load a configuration file from anywhere in the file system.
XmlWebApplicationContext - Gets information from an xml file outside of the web application.
CAN WE HAVE MULTIPLE SPRING CONFIGURATION FILES?
You can specify multiple Spring configuration files by specifying contextConfigLocation. Parameters are specified separated by commas or spaces.
The ability to specify multiple root Spring configuration files is supported.
HOW IS THE DB CONNECTION IN SPRING CONFIGURED?
Using datasource "org.springframework.jdbc.datasource.DriverManagerDataSource".
HOW TO CONFIGURE JNDI NOT VIA DATASOURCE IN APPLICATIONCONTEXT.XML?
Using "org.springframework.jndi.JndiObjectFactoryBean".
HOW CAN I MANAGE TRANSACTIONS IN SPRING?
Transactions in Spring are managed using Declarative Transaction Management (programmatically managed). The @Transactional annotation is used to describe the need to manage a transaction. In the configuration file, you need to add the transactionManager setting for the DataSource.
HOW DOES SPRING SUPPORT DAO?
Spring DAO provides the ability to work with data access using technologies like JDBC, Hibernate in a convenient way. There are special classes: JdbcDaoSupport, HibernateDaoSupport, JdoDaoSupport, JpaDaoSupport.
The HibernateDaoSupport class is a suitable superclass for Hibernate DAO. It contains methods for getting a session or session factory. The most popular method is getHibernateTemplate() which returns a HibernateTemplate. This template wraps Hibernate checked exceptions into runtime exceptions, allowing your DAOs to remain independent of Hibernate exceptions.
HOW TO INTEGRATE SPRING AND HIBERNATE?
To integrate Hibernate into Spring, you need to include dependencies, as well as set up a Spring configuration file. Because settings differ slightly between projects and versions, see the official Spring and Hibernate documentation for technology-specific settings.
HOW TO ADD SPRING SUPPORT TO THE WEB APP
It is enough to simply specify the ContextLoaderListener in the web.xml file of the application.
CAN XYZ.XML BE USED INSTEAD OF APPLICATIONCONTEXT.XML?
ContextLoaderListener is a ServletContextListener that is initialized when your web application starts up. By default, it loads the WEB-INF/applicationContext.xml file. You can change the default value by specifying the contextConfigLocation parameter.
WHAT IS A CONTROLLER IN SPRING MVC?
The key interface in Spring MVC is the Controller. The controller processes requests for actions taken by users in the user interface, interacting with the service layer, updating the model, and directing users to the appropriate views based on the results of the execution. Controller - is a control tool, communication between the model and the view.
The main controller in Spring MVC is org.springframework.web.servlet.DispatcherServlet. It is specified by the @Controller annotation and is often used with the @RequestMapping annotation, which specifies which requests will be processed by this controller.
WHAT IS THE DIFFERENCE BETWEEN THE @COMPONENT, @REPOSITORY AND @SERVICE ANOTATIONS IN SPRING?
@Component - used to specify a class as a spring bean. When using annotation lookup, such a class will be configured as a spring bean.
@Controller is a special type of class used in MVC applications. Handles requests and is often used with the @RequestMapping annotation.
@Repository - indicates that the class is used to work with searching, getting and storing data. An annotation can be used to implement a DAO pattern.
@Service - indicates that the class is a service for implementing business logic (in fact, it does not differ from Component, but simply helps the developer to indicate the semantic load of the class).
Any of these annotations can be used to point the container to a bean class. But different names make it possible to distinguish the purpose of a particular class.
TELL WHAT YOU KNOW ABOUT DISPATCHERSERVLET AND CONTEXTLOADERLISTENER.
DispatcherServlet - is a servlet that parses requests and routes them to the appropriate controller for processing. In Spring MVC, the DispatcherServlet class is the central servlet that receives requests and routes them to the appropriate controllers. In a Spring MVC application, there can be an arbitrary number of DispatcherServlet instances for different purposes (for example, handling UI requests, REST web service requests, etc.). Each DispatcherServlet instance has its own WebApplicationContext configuration that defines servlet-level characteristics such as servlet-enabled controllers, handler mapping, view recognition, internationalization, validation, type conversion and formatting, and so on.
ContextLoaderListener - listener when starting and ending the Spring WebApplicationContext root class. The main purpose is to bind the life cycle of ApplicationContext and ServletContext, as well as automatic creation of ApplicationContext. You can use this class to access beans from different spring contexts. Configured in web.xml
WHAT IS VIEWRESOLVER IN SPRING?
The ViewResolver interface in Spring MVC (from the org.springframework.web.servlet package) supports view recognition based on the logical name returned by the controller. Many implementation classes are provided to support various view recognition mechanisms.
For example, the UrlBasedViewResolver class supports direct conversion of logical names to URLs. The ContentNegotiatingViewResolver class supports dynamic view recognition based on the media type supported by the client (XML, PDF, JSON, etc.). There are also several implementations to integrate with various view technologies such as FreeMarker (FreeMarkerViewResolver), Velocity (VelocityViewResolver) and JasperReports (JasperReportsViewResolver).
InternalResourceViewResolver - An implementation of the ViewResolver that allows you to find the views that the controller returns to navigate to later. Searches for the given path, prefix, suffix and name.
WHAT IS MULTIPARTRESOLVER AND WHEN TO USE IT?
The MultipartResolver interface is used to download files. There are two implementations CommonsMultipartResolver and StandardServletMultipartResolver that allow the framework to upload files. By default, this interface is not included in the application and must be specified in the configuration file. Once configured, any download request will be sent to this interface.
HOW TO UPLOAD A FILE IN SPRING MVC?
Inside the spring, a MultipartResolver interface is provided to support file loading. What you actually need to do is set up a config file to specify the file upload handler and then set the required method in the spring controller.
HOW TO HANDLE EXCEPTIONS IN SPRING MVC FRAMEWORK?
In Spring MVC, the HandlerExceptionResolver interface (from the org.springframework.web.servlet package) is designed to deal with unexpected exceptions thrown during the execution of handlers. By default, the DispatcherServlet registers the DefaultHandlerExceptionResolver class (from the org.springframework.web.servlet.mvc.support package). This resolver handles certain standard Spring MVC exceptions by setting a special response status code. You can also implement your own exception handler by annotating the controller method with the @ExceptionHandler annotation and passing it the exception type as an attribute. In general, exception handling can be described as follows:
Controller Based - specify methods for handling an exception in the controller class. To do this, you need to mark such methods with the @ExceptionHandler annotation.
Global Exception Handler - To handle global exceptions, spring provides the @ControllerAdvice annotation.
HandlerExceptionResolver implementation - Generic exceptions serve static pages most of the time. The Spring Framework provides the HandlerExceptionResolver interface, which allows you to specify a global exception handler. You can use the implementation of this interface to create your own global exception handlers in your application.
WHAT ARE THE MINIMUM SETTINGS TO CREATE A SPRING MVC APP?
To create a simple Spring MVC application, you need to go through the following steps:
Add spring-context and spring-webmvc dependencies to the project.
Specify a DispatcherServlet in web.xml to handle requests within the application.
Define spring bean definition (by annotation or in xml).
Add a view resolver definition for views.
Set up a controller class to handle client requests.
HOW WOULD YOU CONNECT SPRING MVC FRAMEWORK AND MVC ARCHITECTURE?
Model (Model) - acts as any Java bean in Spring. Within the class, various attributes and properties can be set for use in the view.
Presentation (View) - JSP page, HTML file, etc. serve to display the necessary information to the user. The view hands over processing of requests to the servlet dispatcher (controller).
The DispatcherServlet (Controller) is the main controller in a Spring MVC application that handles all incoming requests and passes them on to various methods in the controllers for processing.
HOW TO ACHIEVE LOCALIZATION IN SPRING MVC APPS?
Spring MVC provides a very simple and convenient way to localize an application. To do this, do the following:
Create a resource bundle file that will contain various options for localized information.
Define messageSource in Spring configuration using ResourceBundleMessageSource or ResourceBundleMessageSource classes.
Define a localceResolver of the CookieLocaleResolver class to enable locale switching.
Using the spring:message element, the DispatcherServlet will determine where to place the localized message in the response.
HOW CAN WE USE SPRING TO CREATE A REST WEB SERVICE THAT RETURNS JSON?
The Spring Framework allows you to create Resful web services and return data in JSON format. Spring provides integration with the Jackson JSON API to be able to send JSON responses to a resful web service. To send a response in JSON format from a Spring MVC application, you need to make the following settings:
Add Jackson JSON dependencies.
Configure the RequestMappingHandlerAdapter bean in the Spring configuration file and set the messageConverters property to use the MappingJackson2HttpMessageConverter bean.
In the controller, use the @ResponseBody annotation to return an Object
HOW TO CHECK (VALIDATE) FORM DATA IN SPRING WEB MVC FRAMEWORK?
Spring supports validation annotations from JSR-303, as well as the ability to create custom implementations of validator classes.
After you configured validation rules in the bean using annotations, we can use @Validate annotation next to ModelAttribute to validate the bean. In case you specify BindingResult parameter after the bean, in the list of method parameters that process the bean from form - in this case all the errors will be in BindingResult. You can use binding result API to validate errors.
WHAT DO YOU KNOW ABOUT SPRING MVC INTERCEPTOR AND HOW IS IT USED?
Interceptors in Spring (Spring Interceptor) are analogous to Servlet Filter and allow you to intercept client requests and process them. There are three places to intercept a client request: preHandle, postHandle, and afterCompletion.
preHandle - the method is used to handle requests that have not yet been passed to the controller's handler method. Must return true to pass to the next interceptor or handler method. False will indicate that the request is processed by the handler itself and that there is no need to pass it on. The method has the ability to throw exceptions and forward errors to the view.
postHandle - Called after the handler method but before being processed by the DispatcherServlet to be passed to the view. Can be used to add options to the ModelAndView object.
afterCompletion - Called after the view has been rendered.
To create a handler, you must extend the abstract HandlerInterceptorAdapter class or implement the HandlerInterceptor interface. You also need to specify interceptors in the Spring configuration file.
TELL ME ABOUT SPRING SECURITY.
The Spring Security project provides a wide range of options for securing an application. In addition to standard settings for authentication, authorization and distribution of roles and mapping of available pages, links, etc., it provides protection against various types of attacks (for example, CSRF). It has many different settings, but remains easy to use.
In this course, we are going to develop with you application, written in Java with Spring Boot. This application will use the powerful API of OpenAI to integrate Slack Messenger with Jira and automate project governance.
Also, we are going to learn a lot of other different things and we will include them in our Application.
That’s why, we need to learn and understand the basics of OpenAI, and after that jump to the application implementation.
During the course, we create a Web application for Project Management operations automation.
To implement this application we are going to use the following stack:
Spring Boot Web App
Slack
GPT
Jira
That's why we need to learn Jira and the basics of Jira API in order to build all the required integrations. And that is why this section is needed :)
Hope you would enjoy this section.
Kind regards,
Andrey