Example analysis of read and write operations in Java Spring

Storing bean objects

When we stored bean objects before, we needed to add a line of beans to the configuration file to inject them

This injection method is not good. If there is an error in the configuration file, the program will not display the error message. This is very unfriendly to beginners.

1. Create a project

Create startup class and main method

Introduce dependencies

<dependencies>
   <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-context</artifactId>
        <version>5.2.3.RELEASE</version>
    </dependency>

    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-beans</artifactId>
        <version>5.2.3.RELEASE</version>
    </dependency>
</dependencies>

Create configuration file

We agreed that the bean object to be created will be placed under the com.bean package:

<dependencies>
   <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-context</artifactId>
        <version>5.2.3.RELEASE</version>
    </dependency>

    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-beans</artifactId>
        <version>5.2.3.RELEASE</version>
    </dependency>
</dependencies>

2. Add annotations to store beans in the container

The core of using Spring is to use annotations. There are 5 annotations we have learned.

@Controller [Controller] @Service [Service] @Repository [Warehouse] @Configuration [Configuration/Layout] @Component [Component] 2.1 controller

We were able to get the object by passing in the id parameter before, but that was adding a line of beans to manually add the id, but now that we use annotations, can we only use class types? Get it?

When we use annotations to inject bean objects, the id actually defaults to the camel case form of the class name:

The reason will not be explained first. , will be discussed later.

Easy mistakes:
We previously added the root directory for bean object search in the configuration file, which means that the search will start from this directory downwards, but not upwards ：

Lower-level directory

##Superior directory

##2.2 Service

#2.3 Repository

##2.4 Configuration

##2.5 Component

2.6 Why are there 5 major categories of annotations

in the company Everyone is responsible for different areas, so the class annotations used are also different, but the essence of the five major categories of annotations is the same.

We can clearly see through the two class annotations that the other four annotations are methods that introduce the Component annotation. In other words, Component is the father of the other four class annotations. So what does Component do? It’s just that it’s not easy to throw it into the other four classes when annotating it~

2.7 Why does the id default to a small camel number

We use global search:

Find AnnotationBeanNameGenerator:

##Test:

2.8 Using bean annotations

Bean annotation is a method annotation, when used on a method , the returned object will also be injected by Spring, but it needs to be used with five major categories of annotations (any one will do)

id is the method name.

2.8.1 Rename bean

##2.8.2 Rename multiple

Note

: When renaming using the name attribute, the original method name will lose its effect, which means that only the modified one can be used The name is used as the ID. Get the bean object

Getting the bean object is also called object injection. There are three methods:

Property injection
Constructor injection
Setter injection
1. Property injection

1.1 Autowired

##Although there seems to be no problem now, when we Objects of the same type have been injected multiple times:

At this time, you need to accurately locate the selected object. Type name

:

##1.2Resource

1.3 The difference between the two

Resource has a name attribute, which can specify the name of the injected bean

But Autowired also has a matching annotation, @Qualifier, which can also specify the selected bean object, so the two Well, I think it’s a tie

ps: The Autowired annotation initially queries all types for the types of objects that need to be injected. However, Autowired can only inject one object at a time, so an error will be reported when an object of the same type is injected multiple times. The Qualifier annotation essentially filters the results of its query.

2. Constructor injection

or use Autowired annotation:

##ps

: When there is only one constructor, Autowired can be omitted

but cannot be omitted when there are more than two constructors

Setter injection

or through Autowired

## Resource also supports Setter injection.

Classic interview questions

What are the differences between property injection, constructor injection, and Setter injection?

The above is the detailed content of Example analysis of read and write operations in Java Spring. For more information, please follow other related articles on the PHP Chinese website!