Spring Boot
- What is Spring Boot?
Answer: Spring Boot is a framework that simplifies the development of Spring applications by providing defaults and auto-configuration for various components. It reduces the need for extensive manual configuration, enabling developers to focus on writing business logic.
2. Explain the advantages of using Spring Boot.
Answer: Spring Boot offers several advantages:
Rapid development: It provides a wide range of pre-configured components, reducing development time.
Auto-configuration: Spring Boot automatically configures application components based on the classpath.
Embedded web server support: It allows applications to be packaged as executable JARs with built-in web servers.
Simplified dependency management: It provides starters that encapsulate common dependencies.
3. How does Spring Boot achieve "convention over configuration?
Answer: Spring Boot follows sensible defaults and smart conventions that eliminate the need for explicit configuration. It reduces boilerplate code and configuration by making intelligent assumptions based on your project's dependencies.
4. What is a Spring Boot starter?
Answer: A Spring Boot starter is a collection of pre-configured dependencies that encapsulate a specific functionality. It simplifies dependency management by grouping related libraries, allowing developers to add features to the application with minimal effort.
5. Explain the role of `@SpringBootApplication` annotation.
Answer: `@SpringBootApplication` is a combination of three annotations:
`@Configuration`: Marks the class as a source of bean definitions.
`@EnableAutoConfiguration`: Enables Spring Boot's auto-configuration feature.
`@ComponentScan`: Scans for components, services, and controllers in the package and its sub-packages.
6. How can you define an external configuration file in Spring Boot?
Answer: Spring Boot supports external configuration through properties files (e.g., `application.properties` or `application.yml`). You can place these files in the classpath or the root of the project.
7. What is the purpose of Spring Boot Actuator?
Answer: Spring Boot Actuator provides endpoints for monitoring and managing applications in production. These endpoints offer information about application health, metrics, environment, and more, aiding in operational tasks.
8. Explain the difference between `@Component`, `@Service`, `@Repository`, and `@Controller`.
Answer: These are stereotypes for Spring components:
`@Component`: Generic stereotype for any Spring-managed component.
`@Service`: Indicates that a class is a service layer component.
`@Repository`: Identifies a class as a data access component (DAO).
`@Controller`: Marks a class as a Spring MVC controller handling HTTP requests.
9. How can you create a RESTful API using Spring Boot?
Answer: To create a RESTful API, you define a class with methods annotated with HTTP method annotations like `@GetMapping`, `@PostMapping`, etc. You return objects that will be serialized to JSON or XML.
10. Explain Spring Boot's support for JPA (Java Persistence API).
Answer: Spring Boot simplifies JPA usage through Spring Data JPA. It provides repository interfaces that extend `JpaRepository`, reducing boilerplate code for database operations.
11. What is Spring Boot's `@Autowired` annotation used for?
Answer: `@Autowired` is used for dependency injection. It automatically injects the required beans into your classes, promoting loose coupling.
12. How can you handle exceptions in a Spring Boot application?
Answer: You can create custom exception classes that extend `RuntimeException`. Use `@ExceptionHandler` methods in controllers to handle exceptions gracefully. You can also use `@ControllerAdvice` to define global exception handling.
13. Explain the concept of AOP (Aspect-Oriented Programming) in Spring Boot.
Answer: AOP allows you to modularize cross-cutting concerns, such as logging or security. Spring Boot supports AOP through annotations like `@Aspect` to define aspects and `@Around` to intercept method invocations.
14. What is Spring Boot's `@Transactional` annotation used for?
Answer: `@Transactional` is used to manage database transactions. It ensures that a series of operations are treated as a single unit of work, either committing all or rolling back all in case of failure.
15. How can you configure a data source in Spring Boot for database connectivity?
Answer: Configure a data source by specifying database-related properties in the `application.properties` or `application.yml` file. Spring Boot uses these properties to set up the database connection.
16. Explain Spring Boot's support for caching.
Answer: Spring Boot provides caching support through annotations like `@Cacheable`, `@CacheEvict`, and `@CachePut`. It simplifies caching integration by offering seamless interaction with caching providers like EhCache and Redis.
17. What is the purpose of Spring Boot Test annotations like `@SpringBootTest` and `@WebMvcTest`?
Answer: These annotations facilitate testing in Spring Boot:
`@SpringBootTest`: Loads the complete application context for integration testing.
`@WebMvcTest`: Focuses on testing only the web layer by providing a slice of the application context.
18. How does Spring Boot handle internationalization and localization?
Answer: Spring Boot supports internationalization by reading messages from properties files, allowing your application to serve content in different languages based on the user's locale.
19. Explain Spring Boot's support for externalized configuration.
Answer: Externalized configuration in Spring Boot refers to the practice of storing configuration properties outside the application codebase. This enables different configurations for various environments, without needing code changes.
20. How can you secure a Spring Boot application?
Answer: Spring Boot leverages Spring Security for securing applications. You can implement security using various mechanisms like form-based authentication, OAuth2, and JSON Web Tokens (JWT).
21. What is 'IOC' in spring boot application?
Answer: "IOC" stands for "Inversion of Control." It's a fundamental design principle and a core feature of the Spring Framework.
In a traditional programming model, when we need an object, we create it directly using the new keyword or a factory method. However, with IOC, we define the structure of your application using configuration (XML, annotations, or Java code) and let the framework take care of creating and managing objects.
Spring Boot's IOC container manages the lifecycle of objects, their dependencies, and their configuration. This has several advantages:
Decoupling: Your application components become decoupled from each other and from the specific implementation details, making your code more maintainable and flexible.
Ease of Testing: Dependency injection makes it easier to replace real implementations with mock objects for testing purposes.
Modularity: You can build and configure your application using smaller, reusable components that can be easily swapped or updated without affecting the entire application.
Scalability: Spring Boot's IOC container can manage the lifecycle of objects, helping you manage resources efficiently in large-scale applications.
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
@Service
public class UserService {
private UserRepository userRepository;
@Autowired
public UserService(UserRepository userRepository) {
this.userRepository = userRepository;
}
In a Spring Boot application, IOC and dependency injection are achieved through the use of annotations such as @Autowired, @Component, @Service, @Repository and others.
//
22. What is DI in spring boot application
Dependency Injection (DI) is a design pattern and a core principle of the Spring Framework, including Spring Boot applications. It's closely related to the concept of Inversion of Control (IoC). Dependency Injection is a way of implementing IoC, where the framework is responsible for providing the required dependencies to a class rather than the class creating them itself.
In a Spring Boot application, Dependency Injection is achieved through the following steps:
1. Defining Beans: Components that need to be managed and injected by Spring are annotated with appropriate annotations such as `@Component`, `@Service`, `@Repository`, or `@Controller`. These annotations tell Spring that these classes should be treated as beans and managed by the Spring container.
2. Constructor Injection: Dependencies are injected into a class through its constructor. This is typically the recommended and most common way of performing dependency injection in Spring Boot. You annotate the constructor with `@Autowired`, and Spring automatically identifies the required dependencies and injects them at runtime.
3. Setter Injection: You can also use setter methods to inject dependencies. By annotating a setter method with `@Autowired`, Spring will inject the required dependency when the method is called.
Here's an example of how Dependency Injection works in a Spring Boot application:
@Service
public class UserService {
private UserRepository userRepository;
@Autowired
public UserService(UserRepository userRepository) {
this.userRepository = userRepository;
}
// Service methods using the userRepository
}
Benefits of Dependency Injection in Spring Boot:
1. Reduced Coupling: Classes are loosely coupled as they don't create their own dependencies. This makes it easier to change and maintain individual components.
2. Testability: In unit tests, you can easily substitute real implementations with mock objects for better testing.
3. Flexibility: You can easily switch between different implementations of a dependency without changing the dependent code.
4. Modularity: Components are designed to be self-contained and easily replaceable, promoting a modular architecture.
5. Centralized Configuration: Dependencies can be managed and configured centrally in Spring configuration files or through Java configuration classes.
23. Could you please explain Spring Boot annotations in detail?
Answer :These annotations play a crucial role in configuring and managing various aspects of a Spring Boot application.
1. @SpringBootApplication:
- This is the main annotation that indicates the entry point of a Spring Boot application. It combines three annotations: `@Configuration`, `@EnableAutoConfiguration`, and `@ComponentScan`.
- `@Configuration` indicates that the class contains Spring bean definitions.
- `@EnableAutoConfiguration` enables automatic configuration of the Spring application context based on classpath settings, dependencies, and other annotations.
- `@ComponentScan` specifies the base packages to scan for Spring components such as beans, controllers, services, and repositories.
2. @Controller:
- This annotation is used to mark a class as a Spring MVC controller, which handles HTTP requests.
- Controllers process incoming requests, invoke business logic, and return a response, often in the form of a view.
- Methods within a `@Controller`-annotated class are typically annotated with `@RequestMapping` to specify the URL mapping for the method.
3. @RestController:
- This annotation combines `@Controller` and `@ResponseBody`.
- It's used for creating RESTful web services, where methods return domain objects directly serialized as JSON or XML, eliminating the need for explicit view resolution.
4. @Service:
- Used to indicate that a class is a Spring service bean.
- Service beans typically hold business logic and are used to encapsulate the application's core functionality.
- They are often used in the service layer of a multi-layered architecture.
5. @Repository:
- Indicates that a class is a Spring repository bean, responsible for data access and interaction with a data store (e.g., a database).
- It often extends interfaces like `CrudRepository` or `JpaRepository` to inherit common CRUD (Create, Read, Update, Delete) methods.
6. @Component:
- A generic stereotype annotation for any Spring-managed component.
- It indicates that a class is a Spring bean, eligible for auto-detection during component scanning.
- It's often used when there's no more specific stereotype annotation available (like `@Service` or `@Repository`).
7. @Autowired:
- Used for dependency injection. It allows Spring to automatically resolve and inject beans into classes that declare dependencies.
- You can use it on fields, constructors, and methods. It works along with constructor injection, setter injection, and field injection.
8. @Value:
- Used to inject values from properties files, environment variables, or other sources into Spring components.
- It can be applied to fields, constructor parameters, or method parameters to set values.
9. @RequestMapping:
- Used to map HTTP requests to methods in a controller class.
- You can specify the HTTP method (GET, POST, etc.), the URL pattern, and other request-related attributes.
- This annotation is often used in conjunction with `@Controller` or `@RestController` annotations.
10. @GetMapping, @PostMapping, @PutMapping, @DeleteMapping:
- These annotations are specialized versions of `@RequestMapping` for specific HTTP methods (GET, POST, PUT, DELETE).
- They provide a more concise way to define mappings for specific methods without specifying the HTTP method explicitly.
11. @Configuration:
- Indicates that a class contains bean definitions and should be processed by the Spring container during application context initialization.
- Configuration classes are often used to define beans and manage configuration settings.
12. @EnableAutoConfiguration:
- Enables Spring Boot's automatic configuration feature.
- Spring Boot tries to automatically configure the application based on the classpath and the dependencies included.
13. @Conditional:
- This is a meta-annotation used to create custom conditional annotations.
- You can define conditions under which a component or configuration should be enabled or disabled.
14. @Profile:
- Used to activate or deactivate beans or configuration classes based on specified profiles.
- Profiles allow you to define different sets of beans or configuration for different environments (e.g., development, production).
15. @Primary:
- Used to indicate the primary bean to be injected when there are multiple candidates for a particular dependency.
- It helps in resolving ambiguities when there are multiple beans of the same type.
16. @Qualifier:
- Used to specify which bean should be injected when multiple beans of the same type are available.
- It works in combination with `@Autowired` to explicitly specify the desired bean.
These are just a selection of Spring Boot annotations, and there are many more available for various purposes. Each annotation serves a specific role in configuring and managing Spring Boot applications, helping you achieve modular, maintainable, and flexible code.
24. What is content Negotiaton in spring boot?
Content negotiation in Spring Boot is a mechanism that allows a client and a server to agree on the format of the data being exchanged. This is particularly important in web applications and RESTful APIs that support multiple formats of data representation, such as JSON, XML, HTML, etc.
Spring Boot supports content negotiation through the use of the `produces` attribute in the `@RequestMapping` annotation or its derived annotations, like `@GetMapping`, `@PostMapping`, etc. By specifying the `produces` attribute, you can indicate the media types that the controller method can produce as a response. Here's an example:
Client Request: When a client sends a request to a Spring Boot application, it can include an `Accept` header in the request to indicate its preferred media types (e.g., JSON, XML).
Content Negotiation: Spring Boot examines the `Accept` header in the incoming request to determine the preferred media type of the client.
Controller Handling: In your Spring MVC controller methods, you can use the `produces` attribute in the `@RequestMapping` or similar annotations to specify the media types your method can produce. For example:
Throught the controller
@RestController
@RequestMapping("/api")
public class ApiController {
@GetMapping(value = "/data", produces = MediaType.APPLICATION_JSON_VALUE)
public ResponseEntity<Map<String, Object>> getDataAsJson() {
// Code to fetch and return data
}
@GetMapping(value = "/data", produces = MediaType.APPLICATION_XML_VALUE)
public ResponseEntity<String> getDataAsXml() {
// Code to fetch and return data in XML format
}
}
Through the configration file
@Configuration
public class WebConfig implements WebMvcConfigurer {
@Override
public void configureContentNegotiation(ContentNegotiationConfigurer configurer) {
configurer
.defaultContentType(MediaType.APPLICATION_JSON)
.mediaType("json", MediaType.APPLICATION_JSON)
.mediaType("xml", MediaType.APPLICATION_XML);
}
}
4. Response: Based on the client's preferred media type and the available options specified in the controller method, Spring Boot will automatically serialize the response data into the appropriate format (e.g., JSON) and set the `Content-Type` header of the response accordingly.
5. Fallback: If the client's preferred media type is not available or not specified in the controller's `produces` attribute, Spring Boot will use a default media type based on the first one specified in the `produces` list.
25. How can versioning of REST APIs be implemented in Spring Boot?
Versioning of REST APIs in Spring Boot can be implemented using various strategies. Here are some common approaches:
1. URL Path Versioning:
In this approach, the version information is included directly in the URL path.
@RestController
@RequestMapping("/v1/users")
public class ApiControllerV1 {
// Controller methods for version 1
}
@RestController
@RequestMapping("/v2/users")
public class ApiControllerV2 {
// Controller methods for version 2
}
Clients access the desired version by using the corresponding URL, such as "v1/users" or "/v2/users".
2. Request Parameter Versioning:
Version information is passed as a query parameter in the request.
@RestController
@RequestMapping("/api")
public class ApiController {
@GetMapping(value = "/data", params = "version=1")
public ResponseEntity<String> getDataV1() {
// Version 1 implementation
}
@GetMapping(value = "/data", params = "version=2")
public ResponseEntity<String> getDataV2() {
// Version 2 implementation
}
}
Clients request the desired version by appending the version parameter to the URL, like "/api/data?version=1" or "/api/data?version=2".
3. Request Header Versioning:
Version information is passed as a custom header in the request.
@RestController
@RequestMapping("/api")
public class ApiController {
@GetMapping(value = "/data", headers = "API-Version=1")
public ResponseEntity<String> getDataV1() {
// Version 1 implementation
}
@GetMapping(value = "/data", headers = "API-Version=2")
public ResponseEntity<String> getDataV2() {
// Version 2 implementation
}
}
Clients specify the desired version by including the "API-Version" header in their request.
4. Accept Header Versioning:
Version information is passed in the `Accept` header of the request.
@RestController
@RequestMapping("/api")
public class ApiController {
@GetMapping(value = "/data", produces = "application/vnd.myapp.v1+json")
public ResponseEntity<String> getDataV1() {
// Version 1 implementation
}
@GetMapping(value = "/data", produces = "application/vnd.myapp.v2+json")
public ResponseEntity<String> getDataV2() {
// Version 2 implementation
}
}
Clients specify the desired version in the `Accept` header, like "application/vnd.myapp.v1+json" or "application/vnd.myapp.v2+json".
Select the versioning strategy that best suits your project's requirements and team's preferences. Keep in mind the considerations for cacheability, discoverability, and client usability when making your choice.
Note:
Factors to consider
URI Pollution
Missuse of HTTP Headers
Caching
Can we execute the request on the browser?
API Documentation
Summary: No perfect Solution
26. Could you provide instructions on how to implement HATEOAS for Spring Boot REST APIs using the Spring HATEOAS library?
HATEOAS (Hypermedia as the Engine of Application State) is a concept in RESTful APIs where hypermedia links are embedded in the responses to guide clients on how to navigate through the application. Spring HATEOAS is a library that helps you implement HATEOAS in your Spring Boot REST APIs. It provides tools to generate hypermedia links and representations in accordance with the HATEOAS principle.
Here's how you can implement HATEOAS in Spring Boot REST APIs using the Spring HATEOAS library:
1. Add Dependency:
Include the Spring HATEOAS dependency in your `pom.xml` or `build.gradle` file.
For Maven:
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-hateoas</artifactId>
</dependency>
For Gradle:
implementation 'org.springframework.boot:spring-boot-starter-hateoas'
2. Create Resource Classes:
Create resource classes that extend `ResourceSupport` or use the `Resource` class from Spring HATEOAS. These classes encapsulate the data and hypermedia links for your resources.
import org.springframework.hateoas.RepresentationModel;
public class MyResource extends RepresentationModel<MyResource> {
private String value;
// Getters and setters
}
3. Controller Implementation:
In your controller methods, create instances of your resource classes, add hypermedia links using the methods provided by Spring HATEOAS, and return them as part of the response.
import org.springframework.hateoas.EntityModel;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;
@RestController
public class MyController {
@GetMapping("/resource")
public EntityModel<MyResource> getResource() {
MyResource resource = new MyResource();
resource.setValue("Hello, HATEOAS!");
EntityModel<MyResource> entityModel = EntityModel.of(resource);
entityModel.add(linkTo(methodOn(MyController.class).getResource()).withSelfRel());
return entityModel;
}
}
4. Testing:
Test your API using a tool like cURL, Postman, or a web browser. You should see the hypermedia links embedded in the response, indicating how clients can navigate to related resources.
5. Discoverability:
Clients can use the hypermedia links in the responses to navigate the API and understand the available actions and related resources without having to hardcode URLs.
By implementing HATEOAS using the Spring HATEOAS library, you enhance the discoverability and self-documentation of your REST API, making it more user-friendly for both developers and clients.
27. What is the purpose of Spring Boot Actuator?
Spring Boot Actuator is a set of production-ready features that help us monitor and manage your Spring Boot applications in production environments. It provides various endpoints and tools to gather insights into the running application, manage application components, and diagnose issues.
Some of the key features provided by Spring Boot Actuator include:
1. Health Indicators: The `/actuator/health` endpoint provides information about the health status of your application. You can use predefined health indicators or create custom ones to check the status of various components like the database, messaging system, and more.
2. Metrics: The `/actuator/metrics` endpoint gives you access to various application metrics, such as memory usage, garbage collection, HTTP requests, and custom metrics you define. These metrics can be crucial for monitoring the performance of your application.
3. Info Endpoint: The `/actuator/info` endpoint provides custom application information that you can define. This could include details like the version of your application, its description, and any other relevant metadata.
4. Environment Properties: The `/actuator/env` endpoint exposes the application's properties and configuration in various profiles, which can be useful for debugging and understanding the runtime environment.
5. Shutdown Endpoint: The `/actuator/shutdown` endpoint allows you to gracefully shut down your application remotely. This is useful for scenarios where you need to manage application instances in a controlled manner.
6. Thread Dump, Heap Dump, and Trace Endpoints: These endpoints help you diagnose issues related to threads, memory usage, and request tracing.
7. Custom Endpoints: You can also create your own custom endpoints to expose specific information or management actions that are relevant to your application.
To include Spring Boot Actuator in your Spring Boot application, you generally need to add the `spring-boot-starter-actuator` dependency to your project. Once added, Actuator endpoints are automatically exposed, and you can configure their behavior using properties in your `application.properties` or `application.yml` file.
For example, to enable all the default endpoints, you can add the following line to your configuration:
in properties file:-
management.endpoints.web.exposure.include=*
28. How can you implement field filtering in a Spring Boot REST API to allow clients to request specific fields in the response?
In Spring Boot, you can implement filtering in REST APIs to selectively include or exclude certain data from the response based on client requests. This can be useful when clients want to retrieve a subset of fields or apply certain conditions to the data.
There are primarily two types of filtering: field filtering and dynamic filtering.
1. Field Filtering:
Field filtering involves returning only a subset of fields from the response. Clients can specify which fields they want using query parameters.
Let's consider an example with an entity class called `User`:
public class User {
private Long id;
private String username;
private String email;
// ... other fields, getters, setters
}
In your controller, you can implement field filtering like this:
@GetMapping("/users")
public MappingJacksonValue getUsers(@RequestParam(name = "fields", required = false) String fields) {
List<User> users = userService.getAllUsers();
SimpleBeanPropertyFilter filter = SimpleBeanPropertyFilter.filterOutAllExcept(fields.split(","));
FilterProvider filters = new SimpleFilterProvider().addFilter("userFilter", filter);
MappingJacksonValue mapping = new MappingJacksonValue(users);
mapping.setFilters(filters);
return mapping;
}
Here, the `@RequestParam` named "fields" is used to specify the desired fields in the response. The `MappingJacksonValue` class allows you to apply Jackson filters to control which fields are serialized.
To enable filtering on the `User` class, you need to configure the Jackson ObjectMapper with a filter:
@JsonFilter("userFilter")
public class User {
// ...
}
2. Dynamic Filtering:
Dynamic filtering is similar to field filtering, but it allows you to define multiple filtering profiles that can be applied based on different scenarios.
You define these profiles using the `@JsonFilter` annotation as shown above and then use the corresponding filter name in the controller when setting up the `MappingJacksonValue`.
In both cases, the client can include the "fields" query parameter with a comma-separated list of field names they want in the response. The Spring Boot application will then only include those specified fields in the JSON response.
Remember that filtering data on the server side is important for security and data optimization. However, filtering should not be used as a replacement for proper security practices. Sensitive information should still be properly secured and not just excluded from the response.
Q. How we handle exception in spring boot project?
Handling exceptions in a Spring Boot project involves using various mechanisms provided by the Spring framework. Here are some common practices to handle exceptions effectively:
Global Exception Handling: Spring Boot allows you to define a global exception handler that catches any unhandled exceptions across the application. You can create a class annotated with `@ControllerAdvice` and define methods annotated with `@ExceptionHandler` to handle specific exception types. These methods can return appropriate responses, such as error messages or HTTP error codes.
Custom Exception Classes: Define custom exception classes that extend `RuntimeException` or any appropriate subclass of `Exception`. These custom exceptions can carry additional information specific to your application context.
Validation and Error Handling for RESTful APIs: When building RESTful APIs with Spring Boot, you can leverage `@Valid` annotation along with the `javax.validation` API to validate input data. If the validation fails, Spring will automatically throw a `MethodArgumentNotValidException`. You can then handle this exception using the global exception handling mechanism.
Error Response DTO: Create a custom Error Response Data Transfer Object (DTO) to encapsulate error information such as error codes, messages, and additional details. Use this DTO to communicate error responses to clients.
Logging: Properly log exceptions using a logging framework (e.g., Log4j, SLF4J) to help diagnose issues in production environments. Ensure that sensitive information is not logged.
Customizing Error Pages: You can configure custom error pages in Spring Boot to display user-friendly error messages for specific HTTP error codes.
Here's an example of how global exception handling can be implemented in Spring Boot:
@ControllerAdvice
public class GlobalExceptionHandler {
@ExceptionHandler(Exception.class)
public ResponseEntity<ErrorResponse> handleException(Exception ex) {
ErrorResponse errorResponse = new ErrorResponse();
errorResponse.setErrorCode(HttpStatus.INTERNAL_SERVER_ERROR.value());
errorResponse.setMessage("Internal server error");
return new ResponseEntity<>(errorResponse, HttpStatus.INTERNAL_SERVER_ERROR);
}
@ExceptionHandler(ResourceNotFoundException.class)
public ResponseEntity<ErrorResponse> handleResourceNotFoundException(ResourceNotFoundException ex) {
ErrorResponse errorResponse = new ErrorResponse();
errorResponse.setErrorCode(HttpStatus.NOT_FOUND.value());
errorResponse.setMessage("Resource not found");
return new ResponseEntity<>(errorResponse, HttpStatus.NOT_FOUND);
}
}
In this example, the `ResourceNotFoundException` is a custom exception that you can throw when a resource is not found. The `GlobalExceptionHandler` will catch this exception and return an appropriate error response.
Remember to design your exception handling based on the specific requirements of your application. Consistent and clear error messages help developers and users understand the issues better.