Shulou(Shulou.com)06/03 Report--

This article mainly shows you "how to use Bean objects in Spring IOC", the content is easy to understand, clear, hope to help you solve doubts, the following let the editor lead you to study and learn "how to use Bean objects in Spring IOC" this article.

Bean object in Spring IOC 1. What is Bean

I suddenly found that I mentioned Bean so many times that I forgot to mention what Bean is. It's all right. It's not too late to talk. Bean in Java is a specification and a special java class. So let's first take a look at the Bean specification.

Bean must generate a public class class.

All properties must be encapsulated, and the property of the Bean class is private.

Property values should be accessed and modified through a set of methods (getXxx and setXxx).

The Bean class must have an empty constructor (the default constructor).

These are the basic specifications of Bean, which we can expand, but these are the most basic ones to be satisfied, otherwise they are not a standard Bean. Let me give you an example of a standard Bean and note the four elements above.

Public class User {private String id; private String name; public User () {} public User (String id, String name) {this.id = id; this.name = name;} public String getId () {return id;} public void setId (String id) {this.id = id;} public String getName () {return name } public void setName (String name) {this.name = name;}}

Yes, Bean is such a special class, which must be kept in mind because it will be often used later.

2. Three construction methods of Bean object.

With spring, we no longer have to worry about the construction of objects, leaving everything to spring. However, no matter how advanced the framework is, he is still doing some very simple things at the bottom, which we may have done by ourselves in the past. So, to learn spring, we need to know both why and why, so let's take a look at the ways in which Bean objects are constructed. By the way, find out what their principle is.

1. Construction method construction

This is one of the most frequently used construction methods. You must be wondering why, in previous cases, we wrote a sentence in the configuration file:

Then the Bean object is constructed by spring and put into the IOC container? In fact, this thing is not very classy, in fact, spring uses reflection to call the default constructor of this class. It's that simple.

So the question is, if we have attributes in our object (temporarily assuming that attributes contain only primitive types and String, object properties will be discussed later), how do we construct them? How should this configuration file be written? Quite simply, every Bean object has a setter method (if you don't remember, you can review the structure of the Bean written above). The framework can pass the desired value to the property by calling the setter method, which is property injection. For example, we try to construct an object that mentions a Bean at the beginning of this article:

What does this configuration mainly do? First, as usual, call the default constructor to construct an object, and then call two setter methods to assign values to the two properties. This is how it is expressed in traditional code:

User user = new User (); user.setId ("666"); user.setName ("666")

Of course, we seldom do this ourselves, and if we need to assign values to attributes, we can directly overload the constructor and directly assign values to attributes while creating objects by passing parameters, which can reduce the amount of code. Let's take a look at how to get the framework to call the parametric constructor of Bean:

This configuration is equivalent to directly calling the parameter constructor. Here arg is the abbreviation of arguement (parameter), so constructor-arg means the parameter list of the construction method, name is obviously the parameter name, and value is the parameter value we want to enter. So we have to fill in values for all the parameters in the parameter list, as we did in the past:

User user = new User ("666", "666")

By now you should know exactly what the spring framework does. What seems to be a high-end framework can only do so, the most basic things can never escape.

two。 Static factory construction

This approach is usually used only in specific scenarios, so let's just take a look at it. The static factory here is similar to the factory model we talked about earlier. First of all, we need to have a factory:

Public class UserFactory {public static User createPerson () {return new User ();} public static User createPerson (Integer id,String name) {return new User (id,name);}}

Let's look at how the configuration file is written:

To create an Bean instance using the static factory method, you need to specify the following attributes for the element in addition to id:

Class: specifies the full class name of the static factory (equivalent to the address of the specified factory)

Factory-method: specifies which method of the static factory creates the Bean instance (specifies which workshop of the factory creates the Bean)

Method parameters: if the static factory method requires parameters, use the element to pass in.

3. Example factory construction

The only difference between an instance factory and a static factory is that we need to instantiate the factory object before we can construct the Bean object we need:

To call the instantiation factory, you need to specify the following attributes except id:

Factory-bean: this property specifies the id of the factory Bean

Factory-method: this property specifies the factory method of the instance factory.

Method parameters: if the static factory method requires parameters, use the element to pass in.

Example factories and static factories are not often used, and the most commonly used in development is the construction method mentioned at the beginning. Now the important question is, what if the property of the Bean object is an object? That's what we're going to talk about next-- dependency injection (DI).

Dependency injection

When we talk about spring IOC, we have to talk about DI. Basically, these two things complement each other and the lips are dead and the teeth are cold, so now let's take a look at the relationship between IOC and DI. Control reversal-IOC (Inversion of Control) means the transfer of control over the creation of an object. In the past, the initiative and timing of creating objects were controlled by themselves, but now this power has been transferred to spring.

One of the most important functions of IOC is to dynamically provide an object with other objects it needs as properties while the system is running. This is achieved through DI (Dependency Injection). Let me give you an example of dependency injection:

For example, Class A needs to use JBDC. In the past, we had to write code in Class A to new a Connection object (let's not consider database connection pooling here). Now that we have spring, we just need to use the configuration file to tell the spring,A class that a Connection object is needed, and class A doesn't need to know how and when the Connection is constructed. At run time, spring constructs a Connection object at the appropriate time and injects it into class A, thus completing control over the relationships between the objects. Class A relies on the property Connection to function properly, and this Connection object is injected into A by spring, hence the name of dependency injection.

After reading so much, do you find that dependency injection is actually the same thing as the attribute injection we mentioned above, which dynamically assigns values to the properties of the object, except that the property here is an object? the attributes mentioned above are simple types. Dependency injection sounds high-end, but it is actually just assigning values to the object properties of an object.

IV. The life cycle of Bean

I talked about how to write a configuration file, so you must be curious about what the state of the Bean should be like all the time within spring. So let's take a look at the life cycle of Bean in spring. However, it is important to note in advance that Spring only helps us manage the full life cycle of the singleton Bean, and the Bean,Spring of multiple prototype will not manage the subsequent life cycle after it has been created and handed over to the user. Singleton mode and multiple mode will be discussed later.

Let's take a look at how our Bean object is generated. This diagram is scary at first, but in fact, a lot of things are extension points that are interspersed with the lifecycle of Bean. We don't need to deal with these extension points at first, our focus should be on the lifecycle of Bean itself.

In fact, the life cycle of Bean has only four stages, which are:

Instantiate Instantiation

Attribute assignment Populate

Initialize Initialization

Destroy Destruction

To thoroughly understand the life cycle of Spring, you must first keep these four stages in mind. Instantiation and attribute assignment correspond to the injection of constructor and setter method, initialization and destruction are two stages in which users can customize the extension. We can write the logic we need in these two functions. The various expansion points interspersed between these four stages will be discussed later.

First, let's take a look at the first three. Their main logic is in the doCreateBean method, calling three methods sequentially, which correspond to the three lifecycle phases one by one:

/ / PS: the following code has deleted the parts that you don't need to know for the time being, leaving only the core part protected Object doCreateBean (final String beanName, final RootBeanDefinition mbd, final @ Nullable Object [] args) throws BeanCreationException {/ / Instantiate the bean. BeanWrapper instanceWrapper = null; if (instanceWrapper = = null) {/ / instantiate instanceWrapper = createBeanInstance (beanName, mbd, args);} / / Initialize the bean instance. Object exposedObject = bean; try {/ / attribute assignment populateBean (beanName, mbd, instanceWrapper); / / initialize exposedObject = initializeBean (beanName, exposedObject, mbd);}}

With these three, plus one destruction, make up the four most important life cycle phases of Bean. As shown in the following figure, of course, the following figure adds some extension points in addition to these four basic lifecycle phases:

At the beginning, we only need to know the existence of these extension points. As for how they should be used, we will talk about them later. What we need to understand here are the four most basic life cycles. Other extension points are rarely used by developers, but they must be understood when reading some Java middleware source code.

The scope of Bean in Ioc

In Spring, you can use the

The scope of the bean is set in the scope attribute of the element to determine whether the bean is single-instance or multi-instance.

By default, the Spring value creates a unique instance of each bean declared in the IOC container, which can be shared across the Ioc container: all subsequent getBean () calls and bean references will return this unique bean. This scope is called singleton, and it is the default scope for all bean.

When the scope of bean is singleton, Spring creates an object instance of bean when the IOC container object is created. When the scope of bean is prototype, the Ioc container creates an instance object of bean when it gets an instance of bean.

The scope and life cycle of bean

Singleton: scope= "singleton"

An application has only one instance of an object. His scope of action is the whole citation.

Life cycle:

Object birth: when the application is loaded and the container is created, the object is created

The object is alive: the object is alive as long as the container is there.

Object death: when the application uninstalls and destroys the container, the object is destroyed

Multiple objects: scope= "prototype"

Each time an object is accessed, the object instance is recreated

Life cycle:

Object birth: when an object is used, create a new object instance

The object is alive: as long as the object is in use, it is always alive

Object death: when the object is not used for a long time, it is reclaimed by java's garbage collector.

The above is all the content of the article "how to use Bean objects in Spring IOC". Thank you for reading! I believe we all have a certain understanding, hope to share the content to help you, if you want to learn more knowledge, welcome to follow the industry information channel!

Welcome to subscribe "Shulou Technology Information " to get latest news, interesting things and hot topics in the IT industry, and controls the hottest and latest Internet news, technology news and IT industry trends.