To start with Java Spring, it’s helpful to understand a few of its key concepts. These concepts include Dependency Injection, Model-View-Controller (MVC), and Properties. Let’s look at some examples of these concepts and how you can use them to build a simple project.
In this step-by-step java spring tutorial, you’ll learn about properties in Spring and how they affect your application. In a Spring application, properties are used to provide additional functionality to the user. You can add these properties to your application through several different sources, including Java properties files, YAML files, and command-line arguments. In this tutorial, we’ll learn about setting up property sources, injecting configuration values, and overriding the default value.
To define properties, use the @Validated annotation. An annotation with this value means that the properties are valid.
This tutorial introduces you to the concept of Dependency Injection or DI. The concept of DI is used to solve dependency problems through the use of interface types. Using this technique, managed beans can reference injected instances via the interface type. In the following tutorials, we will see examples of using DI in the context of a Spring Application.
DI is used to remove unnecessary dependencies between classes. The underlying framework is called Spring. The framework centers on the ApplicationContext interface, which implements DI responsibilities. The application context registers eligible classes through Java or XML-based configurations. When a bean is registered with the ApplicationContext, it asks for objects to be created. Then, it builds a dependency tree and traverses it.
In a traditional IoC container, beans declare dependencies in the form of properties, constructor arguments, or static-factory methods. These dependencies are delivered to the bean when it is created. A property can be a value or a reference to another bean. Values can be specified in a string format, but Spring can also transform them to any built-in type. In the following example, we define a property and its reference using XML-based configuration metadata.
The Spring IoC container consumes configuration metadata, which represents the application developer’s instructions. These instructions are typically provided in XML format.
The Spring MVC framework supports both dynamic and static pages. You can use the @RequestParam annotation to bind the request parameters to method arguments. You can also use the @ModelAttribute annotation to bind the request parameters to method arguments.
MVC is a fundamental pattern that can be used to build web applications. In this pattern, a Model represents the data of the application. This model will typically consist of POJOs. A View renders an HTML page based on the data in the Model. A Controller processes user requests and builds an appropriate model, which then passes it to the View. This pattern allows the development of different components to occur in parallel.
The application uses two JSP pages (JSP pages are referred to as views in MVC terminology). A first view is an HTML form, which contains an input field. The second view displays a message saying “Hello”. The controller manages the views and handles user input. It also decides which view to returning. This controller is called HelloController.
To use the @ComponentScan annotation in a Spring context, you first need to define a filter. The filter specifies which types should be eligible for component scanning. It can be an include filter or an exclude filter. The following code demonstrates how to use a filter.
The @ComponentScan annotation in a Spring context will tell Spring to look for potential Spring beans. When this annotation is used in a UserDAO, you can pass in a list of data sources to the UserDAO. Otherwise, a NoSuchBeanDefinition exception will be thrown.
Annotations in a Spring context are like metadata for your application. They provide supplementary information about a program without affecting its behavior. The @ComponentScan annotation is the most important one and is used with the @Configuration annotation to specify which packages should be scanned. Annotating a class with @ComponentScan means that the class will be treated as a spring component by the framework.