Unit 5 Oops With Java
Uploaded by
mail.aashiagrUnit 5 Oops With Java
Uploaded by
mail.aashiagr5.1 Spring is a lightweight framework 5.
7 Dependency Injection (DI)
It is a comprehensive framework for building Java applications.
● ● It is a design pattern used to implement Inversion of Control (IoC) in
● It provides infrastructure support, reducing the need for boilerplate software development
code. ● making it easier to manage dependencies between different
● It uses Inversion of Control (IoC) to manage object creation and components.
dependency injection. ● This pattern enhances modularity, maintainability, and testability of
● It supports Aspect-Oriented Programming (AOP) for separating code by decoupling the creation of an object from its usage.
cross-cutting concerns. ● Dependency: An object that another object relies on.
● It provides a powerful Model-View-Controller (MVC) framework for web ● Injection: The process of passing the dependent object to a dependent
applications. object.
● It offers Spring Boot for easier setup and configuration of new Spring
applications. 5.8 Types of Dependency Injection
5.2 Inversion of Control (IoC): ● Constructor Injection:
● Dependencies are provided through a class constructor.
● A design principle where the control of creating and managing objects
● Most common and recommended type.
is transferred from the application itself to a container or framework.
● Ensures that dependencies are not mutable and that the object is
● Example: Instead of a class instantiating its dependencies,the container
always in a consistent state.
provides them.
publicclassCar{
5.3 Container: privateEngineengine;
● T he component in Spring that implements IoC. It creates, configures, publicCar(Engineengine){
and manages beans. this.e ngine=engine;
}
● Example: Spring's ApplicationContext and BeanFactory are examples of
}
containers. ● Setter Injection:
● Dependencies are provided through setter methods.
5.4 Dependency Injection (DI): ● Allows the dependencies to be replaced or changed after the
● A specific form of IoC where the container injects dependencies into an object is created.
object, rather than the object creating them itself.
publicclassCar{
● Types: privateEngineengine;
● Constructor Injection:Dependencies are provided througha class
constructor. publicvoidsetEngine(E ngineengine){
this.e ngine=engine;
● Setter Injection: Dependencies are provided throughsetter }
methods. }
● Field Injection:Dependencies are directly injected into fields. ● Field Injection:
● Dependencies are provided directly into fields.
5.5 Beans: ● This approach can be less flexible and harder to test.
● Only used for reference variable
● T he objects that the Spring IoC container manages. They form the
backbone of a Spring application. publicclassCar{
● Example: A service class, a repository class, or aconfiguration class can @Autowired
be beans. privateEngineengine;
}
5.6 Correlation Between Spring ioc components
5.9 Benefits of Dependency Injection
T heSpring Frameworkprovides theIoC Container, whichmanagesBeans.
● ecoupling: Objects are decoupled from their dependencies,
D
TheIoC ContainerusesConfiguration Metadatato knowhow to create and
making the code more modular.
configure beans.
● Easier Testing:Dependencies can be mocked or stubbed out
Dependency Injection (DI)is used by the containerto inject dependencies
easily, improving testability.
into beans.
● Flexibility: Dependencies can be changed without modifying the
Aspect-Oriented Programming (AOP)is applied to beansto handle
dependent class.
cross-cutting concerns, enhancing their functionality.
● Improved Code Quality: Promotes the use of interfaces and
abstractions, leading to cleaner and more maintainable code.
5.10 Aspect oriented programming (AOP)
● D eclarative Transaction Management:Spring AOP allows developers to
manage transactions without tightly coupling them to business logic.
● Modularization of Crosscutting Concerns:AOP in Spring helps to
modularize concerns like logging, security, and caching, which impact
multiple parts of an application.
● Custom Aspect Implementation: Developers can create reusable
aspects in Spring AOP to encapsulate crosscutting concerns,
complementing traditional OOP.
● Enhancement of Spring IoC:While not mandatory, integrating AOP with
Spring IoC enhances its capabilities by combining dependency injection
with aspect-oriented programming.
● I mproved Modularity and Maintainability:AOP enriches the Spring x ml config:
framework by promoting a cleaner separation of concerns and <b
ean id="singletonBean"class="com.example.SingletonBean"/>
facilitating easier maintenance of enterprise applications. java config:
@Bean
5.11 Bean in Spring publicSingletonBeansingletonBean(){
returnnewSingletonBean();
● In the Spring Framework, a bean is an object that is instantiated,
}
assembled, and managed by the Spring IoC (Inversion of Control)
container.
. P
2 rototype Scope
● It represents a fundamental building block of a Spring application.
● Prototype scope creates a new instance of the bean whenever
requested. Each time you ask for a prototype bean, Spring creates
5.12 Key Characteristics of a Bean: a new instance.
● B eans are defined in Spring configuration metadata, either XML-based ● Useful for stateful beans where each client needs its own instance.
(applicationContext.xml) or Java-based (annotations or Java ● Configuration:
x ml config:
configuration classes).
<b
ean id="prototypeBean"class="com.example.SingletonBean"
● Example in XML scope="prototype"/>
<bean id="userService"class="com.example.UserService"/> java config:
@Bean
@Scope("prototype")
● Instantiation: publicPrototypeBeanprototypeBean(){
● The Spring IoC container creates beans based on their returnnewPrototypeBean();
}
configuration.
● Beans can be instantiated using default constructors or specific
. R
3 equest Scope
factory methods.
● Request scope creates a new instance of the bean for each HTTP
● Configuration: request. This scope is available only for web-aware Spring
● Beans can be configured with dependencies (other beans), ApplicationContext.
properties (simple values), initialization methods, destruction ● Used for beans that need to be recreated for every HTTP request,
methods, etc. such as request-specific data.
● Example with dependencies in XML: ● Configuration:
x ml config:
<bean id="userService"class="com.example.UserService"> <b
ean id="requestBean"class="com.example.RequestBean"
<p
roperty name="userDao"ref="userDao"/> scope="request"/>
</bean>
java config:
● Dependency Injection: @Bean
@Scope(v alue="r equest",proxyMode=
● Spring injects dependencies into a bean's properties or ScopedProxyMode.TARGET_CLASS)
constructor at runtime. publicRequestBeanrequestBean(){
● Example using constructor injection: returnnewRequestBean();
}
publicclassUserService{ . S ession Scope
4
privatefinalUserDaouserDao;
● Session scope creates a new bean instance for each HTTP session.
publicUserService(UserDaouserDao){ This scope is also specific to web-aware Spring ApplicationContext.
this.u
serDao=userDao; ● Suitable for beans that store session-specific information, like user
}
}
preferences or shopping cart details.
● Configuration:
● Lifecycle Management: x ml config:
● The Spring IoC container manages the lifecycle of beans, including <b
ean id="sessionBean"class="com.example.SessionBean"
scope="session"/>
instantiation, initialization, usage, and optional destruction (for
singleton beans). java config:
● Use@PostConstructand@PreDestroyannotations or @Bean
@Scope(v alue="s ession",proxyMode=
init-method and destroy-method attributes in XML for ScopedProxyMode.TARGET_CLASS)
initialization and destruction methods. publicSessionBeansessionBean(){
returnnewSessionBean();
}
5.13 Scopes of Bean
eans can have different scopes (singleton, prototype, request, session, etc.)
B . A
5 pplication Scope
that define their lifecycle and visibility within the application context. ● Application scope creates a single bean instance per
ServletContext (global to the web application).
.
1 S ingleton Scope ● Useful for beans that need to be shared across the entire
● Singleton scope is the default scope in Spring. It means that Spring application, like a global cache or configuration settings.
container creates exactly one instance of the bean definition and ● Configuration:
shares it throughout the application. x ml config:
● Suitable for stateless beans where a single instance can be shared <b
ean id="applicationBean"class="com.example.ApplicationBean"
by multiple clients. scope="application"/>
● Configuration:
java config: . C
4 onstructor
@Bean ● Autowires by matching the constructor parameters to beans in the
@Scope("application")
publicApplicationBeanapplicationBean(){ container. Constructor injection is generally recommended for
returnnewApplicationBean(); mandatory dependencies.
} ● Example:
.
6 eb Socket Scope
W MLConfiguration:
X
<b ean id="a" class="com.example.A"autowire="constructor"/>
● WebSocket scope is used for beans that are associated with a
<b
ean id="b"class="com.example.B"/>
WebSocket session. It's available only in a WebSocket-enabled
application. J avaConfiguration:
● Suitable for WebSocket-specific beans that maintain state across @Autowired
publicA( Bb){
WebSocket sessions. this.b
=b;
● Configuration: }
java config:
@Bean . A
5 utodetect (Deprecated)
@Scope("websocket")
publicWebSocketBeanwebSocketBean(){ ● Attempts to autowire using constructor first, and if no constructor
returnnewWebSocketBean(); is found, uses byType.
} ● Example: This mode is deprecated and should be avoidedin favor
of explicit autowiring modes.
f or more details: 5.15 Annotations in Spring
https://docs.spring.io/spring-framework/reference/core/beans/factory-scop ● nnotations in Spring provide metadata about the beans and their
A
es.html dependencies.
● They simplify configuration and reduce XML-based configuration.
5.14 Autowiring in Bean ● Usage: Used with components like @Component @Autowired
, ,
● A utowiring is Spring's feature that allows automatic dependency @Scope
@RequestMapping
, , etc.
injection. ● Example:
● It simplifies bean wiring by letting Spring resolve dependencies based
RestController
@
on type or name.
@RequestMapping("/api")
● We used the@Autowiredannotations for the autowiringthe bean publicclassMyController{
● Reduces boilerplate code and manual bean wiring.
Autowired
@
Autowired
@ privateMyServicemyService;
privateDependencydependency; }
● Types: ByType, ByName, Constructor, Autodetect, etc.
.
1 o Autowiring (default)
N 5.16 Lifecycle callbacks
● No automatic wiring is performed. Dependencies must be ● lifecycle callbacks are methods that allow you to hook into specific
manually injected. stages of a bean's lifecycle.
● Example: Default setting, no need for annotation orXML ● These stages include bean creation, initialization, and destruction.
configuration. ● The primary purpose of lifecycle callbacks is to provide a way to execute
custom logic during these stage :
.
2 ByType ● Application Started:Triggered right after the application starts.
● utowires by matching the type of the property to the type of a
A ● Spring Container Started:Triggered when the Spring IoC container
bean in the container. is initialized.
● Example:: ● Bean Constructed & Dependency Injection (DI): Beans are
MLConfiguration:
X instantiated and dependencies are injected.
<bean id="b" class="com.example.B"/> ● Custom Init Call:Custom initialization methods are called after the
<bean id="a" class="com.example.A"autowire="byType"/> bean is constructed.
J avaConfiguration:
● Other Methods Call:Regular business methods are invoked during
@Autowired the application's operation.
privateBb; ● Custom Destroy Call:Custom destruction methods are called
before the application shuts down.
.
3 yName
B
● Autowires by matching the name of the property to the name of a
bean in the container.
● Example:
MLConfiguration:
X
<bean id="a" class="com.example.A"autowire="byName"/>
<bean id="b" class="com.example.B"/>
J avaConfiguration:
@Autowired
privateBb;
5.17 Bean configuration MainApplication.java:
● B ean configuration in Spring refers to defining and managing beans ackagecom.e
p xample;
importorg.springframework.context.ApplicationContext;
within the Spring IoC (Inversion of Control) container. importorg.s pringframework.context.annotation.AnnotationConfigApplicationContext;
● There are several ways to configure beans in Spring: importorg.springframework.stereotype.Component;
● XML Configuration: Defining beans in XML files.
Component
@
● Annotation-Based Configuration: Using annotationsto define and publicclassDemoApplication{
configure beans. publicstaticvoidmain(S tring[]args){
ApplicationContextcontext=newAnnotationConfigApplicationContext("com.example");
● Java-Based Configuration: Using Java classes to configurebeans.
E xampleBeanexampleBean=context.getBean(ExampleBean.class);
exampleBean.display();
.
1 ML Configuration
X }
● Beans are defined in an XML file, typically named }
applicationContext.xml.
applicationContext.xml: . J ava-Based Configuration
3
<b
eans xmlns="http://www.springframework.org/schema/beans" ● Using @Configuration and @Bean annotations to define and
xmlns:x si="http://www.w3.org/2001/XMLSchema-instance" configure beans.
xsi:s chemaLocation="http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans.xsd">
AppConfig.java:
<bean id="exampleBean"class="com.example.ExampleBean"> packagecom.example;
<p
roperty name="propertyName"value="propertyValue"/>
</bean> importorg.springframework.context.annotation.Bean;
</beans> importorg.springframework.context.annotation.Configuration;
Configuration
@
ExampleBean.java: publicclassAppConfig{
ackagecom.example;
p
Bean
@
publicclassExampleBean{
publicExampleBeanexampleBean(){
privateStringpropertyName;
ExampleBeanbean=newExampleBean();
bean.setPropertyName("propertyValue");
publicvoidsetPropertyName(StringpropertyName){
returnbean;
this.propertyName=propertyName;
}
}
}
publicvoiddisplay(){
System.out.println("Property Value:"+propertyName); E xampleBean.java: Same as xml configuration file
} MainApplication.java:
} ackagecom.e
p xample;
importorg.springframework.context.ApplicationContext;
importorg.s pringframework.context.annotation.AnnotationConfigApplicationContext;
MainApplication.java:
ackagecom.example;
p publicclassDemoApplication{
importorg.springframework.c ontext.A pplicationContext; publicstaticvoidmain(S tring[]args){
ApplicationContextcontext=newAnnotationConfigApplicationContext(A
ppConfig.class);
importorg.springframework.c ontext.s upport.ClassPathXmlApplicationContext;
publicclassDemoApplication{ E xampleBeanexampleBean=context.getBean(ExampleBean.class);
publicstaticvoidmain(String[]args){ exampleBean.display();
ApplicationContextcontext=new }
ClassPathXmlApplicationContext("applicationContext.xml"); }
E xampleBeanexampleBean=(ExampleBean)context.getBean("exampleBean"); 5.18 Spring Boot supports
exampleBean.display(); ● S pring Boot supports various build systems that help manage
}
} dependencies, package applications, and automate build tasks.
● The two primary build systems used with Spring Boot are Maven and
.
2 nnotation-Based Configuration
A Gradle:
● Spring provides several annotations to define and configure beans.
1.Maven
● Maven is a widely-used build automation tool primarily for Java
E xampleBean.java:
projects.
packagecom.example;
● It manages project dependencies, builds artifacts, and executes
importorg.springframework.stereotype.C
omponent;
various lifecycle phases like compile, test, package, and install.
C
@ omponent
publicclassExampleBean{ 2.Gradle
privateStringpropertyName="propertyValue";
● radle is a modern build automation tool that combines the
G
publicvoiddisplay(){
flexibility of Ant with the dependency management and
System.out.println("Property Value:"+propertyName);
} conventions of Maven.
} ● It uses Groovy-based DSL (Domain Specific Language) or Kotlin for
configuring builds.
5.19 Choosing Between Maven and Gradle with Spring Boot ● p
om.xml:Maven build configuration file definingdependencies,
plugins, and project settings
1.Maven:
● Widely adopted in the Java ecosystem. 5.21 Logger
● Strong support for dependency management and project lifecycle
management. ● logging is an essential aspect of application development and
● XML-based configuration (pom.xml) might be familiar to many maintenance.
Java developers. ● Spring Boot supports logging through various logging frameworks, with
2.Gradle: SLF4J (Simple Logging Facade for Java) and Logback being the default
● Offers flexibility and concise syntax with Groovy or Kotlin DSL. choices.
● Supports incremental builds and parallel execution of tasks. ● SLF4J is an abstraction for various logging frameworks (e.g.,
● Preferred for its readability and customization options, especially java.util.logging, logback, log4j)allowing the end user to plug in the
for complex projects or where Kotlin is preferred. desired logging framework at deployment time.
● Use logging statements in your classes to output messages at different
5.20 Spring Boot Code Structure levels. Here’s how you can use them:
importorg.slf4j.Logger;
importorg.slf4j.LoggerFactory;
importorg.springframework.stereotype.Service;
Service
@
publicclassMyService{
privatestaticfinalLoggerlogger=LoggerFactory.getLogger(MyService.class);
publicvoiddoSomething(){
logger.trace("This is a TRACE message");
logger.debug("This is a DEBUG message");
logger.info("This is an INFO message");
logger.warn("This is a WARN message");
logger.error("This is an ERROR message");
}
}
5.22 Building RESTful web services
B
● uilding RESTful web services with Spring Boot involves several steps
● including setting up your project, creating controllers, defining
endpoints, and handling requests and responses.
● Here's a step-by-step guide to building RESTful web services in Spring
Boot:
Step 1: Set Up Your Project
● First, set up your Spring Boot project using your preferred method (e.g.,
Spring Initializr, Maven, or Gradle).
Step 2: Create the Main Application Class
● This class will bootstrap your Spring Boot application.
DemoApplication.java:
ackagecom.example.d
p emo;
importorg.springframework.boot.S pringApplication;
importorg.springframework.boot.a utoconfigure.S pringBootApplication;
SpringBootApplication
@
Explanation of Components publicclassDemoApplication{
publicstaticvoidmain(String[]args){
s rc/main/java:Contains the Java source code for your application.
● SpringApplication.r un(DemoApplication.c lass,args);
● com.example.myapplication:Root package structure. Replace }
com.example.myapplicationwith your actual package name. }
● MyApplication.java: Main class annotated with
S tep 3: Create a REST Controller
@SpringBootApplication, which serves as the entry point of the
● Create a controller to handle HTTP requests.
application.
UserController.java:
● controller: Package for Spring MVC controllers handling HTTP requests.
ackagecom.example.d
p emo.controller;
● service: Package for service classes containing business logic. importorg.springframework.web.bind.annotation.*;
● model: Package forPOJOclasses representing data entities. importjava.util.A rrayList;
● src/main/resources: Contains non-Java resources. importjava.util.L ist;
● application.properties: Configuration file for application-specific RestController
@
properties. Can be replaced withapplication.ymlfor YAML-based @RequestMapping("/users")
configuration. publicclassUserController{
privateList<User>users=newArrayList<>();
● static: Directory for static assets likeCSS, JavaScript, images,etc. @GetMapping
● templates: Directory for HTML templates used by SpringMVC publicList<User>getAllUsers(){
(Thymeleaf, FreeMarker,etc.). returnusers;
}
● src/test/java: Contains test code.
● com.example.myapplication: Mirror package structure for testing.
● controller:Package for controller unit tests.
● service:Package for service unit tests.
G
@ etMapping("/{id}") "name":"John Doe"
publicUsergetUserById(@PathVariableintid){ }
returnusers.s tream()
.fi lter(user->user.getId()==id) UThttp://localhost:8080/users/1 //update the record at id=1
P
.fi
ndFirst() Body:{
.o
rElse(n ull); "name":"Jane Doe"
} }
P
@ ostMapping DELETEhttp://localhost:8080/users/1 //delete the record id=1
publicUsercreateUser(@RequestBodyUseruser){
users.add(user);
returnuser; 5.23 @PathVariable
}
P
● urpose: Extract values from the URI path.
P
@ utMapping("/{id}") ● Usage: When values are part of the URL.
publicUserupdateUser(@PathVariableintid,@RequestBodyUserupdatedUser){
● Example: For URL /users/1, extract 1.
for(U seruser:users){
if(user.getId()==id){
GetMapping("/{id}")
@
user.setName(updatedUser.g etName());
publicStringgetUserById(@PathVariable("id")intuserId){
returnuser;
return"User ID:"+userId;
}
}
}
returnnull;
} 5.24 @RequestParam
P
● urpose: Extract query parameters from the URL.
D
@ eleteMapping("/{id}")
publicStringdeleteUser(@PathVariableintid){
● Usage: When values are passed as query parameters.
users.removeIf(user->user.g etId()==id); ● Example: For URL /users?page=2&size=10, extract page=2 and size=10
return"User with ID"+id+"deleted.";
} GetMapping
@
} publicStringgetUsers(@RequestParam("page")intpage,@R
equestParam("size")int
size){
return"Page:"+page+", Size:"+size;
S tep 4: Create a User Model }
● Define a User model class to represent user data.
User.java: 5.25 Using Both Together
packagecom.example.demo.controller;
P
● urpose: Capture values from both the path and query parameters.
publicclassUser{ ● Example: For URL /users/1/orders?page=1&size=5, extract userId=1,
privateintid; page=1, and size=5
privateStringname;
GetMapping("/{id}/orders")
@
ublicUser(){
p publicStringgetUserOrders(@PathVariable("id")intuserId,
} @RequestParam("page")intpage,
@RequestParam("size")intsize){
publicUser(intid,Stringname){ return"User ID:"+userId+", Page:"+page+", Size:"+size;
this.id=id; }
this.name=name;
}
5.26 GET API
publicintgetId(){ P
● urpose: Retrieve resources.
returnid; ● Example: Fetch user details.
} GetMapping("/{id}")
@
publicUsergetUserById(@PathVariable("id")intuserId){
publicvoidsetId(intid){ returnuserService.findUserById(u
serId);
this.id=id; }
}
5.27 POST API
publicStringgetName(){ P
● urpose: Create new resources.
returnname; ● Example: Add a new user.
}
PostMapping
@
publicUsercreateUser(@RequestBodyUseruser){
publicvoidsetName(Stringname){
returnuserService.saveUser(user);
this.name=name;
}
}
} 5.28 PUT API
P
● urpose: Update existing resources.
S tep 5: Running the Application ● Example: Update user details.
● Run the DemoApplication class. Your Spring Boot application will start, PutMapping("/{id}")
@
and the embedded Tomcat server will be launched. publicUserupdateUser(@PathVariable("id")intuserId,@RequestBodyUser
userDetails){
S tep 6: Testing Your RESTful Web Service returnuserService.updateUser(userId,userDetails);
}
● You can use tools like Postman or curl to test your RESTful web service.
5.29 DELETE API
● Examples:
P
● urpose: Delete resources.
GEThttp://localhost:8080/users // get all users ● Example: Remove a user.
DeleteMapping("/{id}")
@
GEThttp://localhost:8080/users/1 // get user id =1 publicResponseEntity<Void>deleteUser(@PathVariable("id")intuserId){
userService.d
eleteUser(userId);
OSThttp:/ /localhost:8080/users // store the record
P returnResponseEntity.noContent().build();
Body:{ }
"id":1,
5.30 REST Controller 5. Controller Class
● Handle web requests.
● Defines RESTful web services Controller
@
RestController
@ @RequestMapping("/users")
@RequestMapping("/api/users") publicclassUserController{
publicclassUserController{ @Autowired
@A utowired privateUserServiceuserService;
privateUserServiceuserService;
} GetMapping
@
publicStringgetAllUsers(Modelmodel){
model.addAttribute("users",userService.g etAllUsers());
5.31 Request Mapping return"user-list";
}
M
● aps HTTP requests to handler methods.
● Maps base URL for all endpoints. GetMapping("/{id}")
@
GetMapping
@ publicStringgetUserById(@PathVariable("id")Longid,Modelmodel){
publicList<U
ser>getAllUsers(){ model.addAttribute("user",userService.getUserById(id));
returnuserService.getAllUsers(); return"user-detail";
} }
GetMapping("/{id}")
@ GetMapping("/new")
@
publicUsergetUserById(@PathVariableLongid){ publicStringcreateUserForm(Modelmodel){
returnuserService.getUserById(id); model.addAttribute("user",newUser());
} return"user-form";
}
PostMapping
@
publicUsercreateUser(@RequestBodyUseruser){ PostMapping
@
returnuserService.saveUser(user); publicStringcreateUser(@ModelAttribute("user")Useruser){
} userService.s aveUser(user);
return"redirect:/users";
PutMapping("/{id}")
@ }
publicUserupdateUser(@PathVariableLongid,@RequestBodyUseruser){
user.setId(id); GetMapping("/edit/{id}")
@
returnuserService.saveUser(user); publicStringeditUserForm(@PathVariable("id")Longid,Modelmodel){
} model.addAttribute("user",userService.getUserById(id));
return"user-form";
DeleteMapping("/{id}")
@ }
publicvoiddeleteUser(@PathVariableLongid){
userService.deleteUser(id); PostMapping("/{id}")
@
} publicStringupdateUser(@PathVariable("id")Longid,@ModelAttribute("user")
Useruser){
user.s etId(id);
5.32 Request Body userService.s aveUser(user);
● Binds HTTP request body to a method parameter. return"redirect:/users";
PostMapping
@ }
publicUsercreateUser(@RequestBodyUseruser){
returnuserService.saveUser(user); GetMapping("/delete/{id}")
@
} publicStringdeleteUser(@PathVariable("id")Longid){
userService.d eleteUser(id);
return"redirect:/users";
5.33 Building Web Applications with Spring Boot }
1. Set Up Project }
● reate a Spring Boot project with dependencies:Spring Web,Thymeleaf,
C
Spring Data JPA.
2. Model Class . Thymeleaf Templates
6
● Define the entity. src/main/resources/templates/user-list.html:
Entity
@ < !DOCTYPEhtml>
publicclassUser{ <h tmlxmlns:th="http://www.thymeleaf.org">
@Id <h ead><title>User List</title></head>
@G eneratedValue(s trategy=GenerationType.IDENTITY) <b ody>
privateLongid; <h 1>User List</h1>
privateStringname; <a href="/users/new">Add New User</a>
privateStringemail; <t able>
// Getters and setters <tr><th>ID</th><th>Name</th><th>Email</th><th>Actions</th></tr>
} <trth:each="user : ${users}">
<tdth:text="${user.id}"></td>
<tdth:text="${user.name}"> </td>
3. Repository Interface
<tdth:text="${user.email}"></td>
● Interface for data access.
ublicinterfaceUserRepositoryextendsJpaRepository<User,Long>{
p
}
<td>
<ath:href="@{/users/{id}(id=${user.id})}">View</a>
5. Service Class <ath:href="@{/users/edit/{id}(id=${user.id})}">Edit</a>
● Handle business logic. <ath:href="@{/users/delete/{id}(id=${user.id})}">D elete</a>
Service
@ </td>
publicclassUserService{ </tr>
@A utowired </table>
privateUserRepositoryuserRepository; </body>
publicList<User>getAllUsers(){returnuserRepository.findAll();} </html>
publicUsergetUserById(L ongid){returnuserRepository.fi ndById(id).orElse(n
ull);}
publicUsersaveUser(Useruser){returnuserRepository.s ave(user);}
publicvoiddeleteUser(Longid){userRepository.d
eleteById(id);}
}
src/main/resources/templates/user-form.html:
< !DOCTYPEhtml>
<h tmlxmlns:th="http://www.thymeleaf.org">
<h ead><title>User Form</title></head>
<b ody>
<h 1>U ser Form</h1>
<f ormth:action="@{/users}"th:object="${user}"method="post">
<inputtype="hidden"th:field="*{id}">
<div><labelfor="name"> N ame:</label><inputtype="text"id="name"
th:field="*{name}"></div>
<div><labelfor="email"> E mail:</label><inputtype="text"id="email"
th:field="*{email}"></div>
<div><buttontype="submit">S ave</button></div>
</form>
<a href="/users"> Back to List</a>
</body>
</html>
src/main/resources/templates/user-detail.html:
< !DOCTYPEhtml>
<h tmlxmlns:th="http://www.thymeleaf.org">
<h ead><title>User Detail</title></head>
<b ody>
<h 1>U ser Detail</h1>
<p > ID:<spanth:text="${user.id}"> </span></p>
<p > Name:<spanth:text="${user.name}"> </span></p>
<p > Email:<s panth:text="${user.email}"></span></p>
<a href="/users"> Back to List</a>
</body>
</html>
. Running the Application
7
● Start the Spring Boot application:Run the DemoApplication class.
● Access the Application: Open a web browser and navigate to
http://localhost:8080/users.
You might also like
- Object Oriented Programming With Java Unit 5No ratings yetObject Oriented Programming With Java Unit 538 pages
- Inversion of Control: Introduction To SpringNo ratings yetInversion of Control: Introduction To Spring45 pages
- Spring Question and Answers What Is A Spring Bean?No ratings yetSpring Question and Answers What Is A Spring Bean?16 pages
- Spring Interview Questions: Q. What Is Spring?No ratings yetSpring Interview Questions: Q. What Is Spring?20 pages
- Allison, Berkowitz - 2008 - SQL For Microsoft Access PDF100% (1)Allison, Berkowitz - 2008 - SQL For Microsoft Access PDF393 pages
- Mastering French Vocabulary With Audio mp3 A The X6FtgcgI 143807153120191002 81207 1a6vcmq PDFNo ratings yetMastering French Vocabulary With Audio mp3 A The X6FtgcgI 143807153120191002 81207 1a6vcmq PDF3 pages
- Finn-Power Turret Punch Press NC Express v6 User Manual100% (3)Finn-Power Turret Punch Press NC Express v6 User Manual148 pages
- Terraform Up and Running Writing Infrastructure As Code 3rd Edition Yevgeniy Brikman No Waiting TimeNo ratings yetTerraform Up and Running Writing Infrastructure As Code 3rd Edition Yevgeniy Brikman No Waiting Time129 pages
- Resume: Indian Institute of Technology (Indian School of Mines), DHANBAD-826004No ratings yetResume: Indian Institute of Technology (Indian School of Mines), DHANBAD-8260042 pages
- Web Applications and Security Revision NotesNo ratings yetWeb Applications and Security Revision Notes10 pages
- Fork, Wait, Exit, Getpid and Getppid Unix System Calls: Lab Manual 07 Process CreationNo ratings yetFork, Wait, Exit, Getpid and Getppid Unix System Calls: Lab Manual 07 Process Creation7 pages
- Property Transfer Report: Fund Cluster: - Jenalyn B. BoctotNo ratings yetProperty Transfer Report: Fund Cluster: - Jenalyn B. Boctot4 pages
