自动装配和对象创建之间有什么区别？

Question

What is the difference, if I autowire a class and provide value and instantiate an object of class and provide some value? For example-

@Autowired
private UserService userService;
userService.findUser(userName, password);

And

User user = new user();
userService.findUser(user.getuserName(),user.getpassword());

What is the difference in Autowiring and sending the data and instantiating the object and sending the data to some service class?

I'm trying to clarify the concepts in spring.

Answer 1

Your example doesn't make a lot of sense; this User class, which looks like some plain data object, isn't adding anything to the second snippet.

The idea of "autowiring" is that some class, like maybe a Web controller, will need a UserService in order to get its work done. When Spring autowires the UserService , it goes into the context and finds a matching object and provides it to the class that needs it. This is technically separate from creating the object.

That said, the best practice is to use constructor injection --simply declare the other objects you need as constructor parameters and annotate the constructor with @Autowired (or @Inject ). Spring will know to look up all the dependencies you need and call the constructor with them. This means that it's also very simple to provide mocks of those objects for testing or development.

Answer 2

When you use @Autowired you are leaving it up to the Spring framework to find and instantiate the userService . This is usually controlled through some configuration file or some other configuration, which allows you to change the behaviour of your application without changing the code itself.

On the other hand, when you instantiate the object yourself, you are specifying which object you are after and what type of class you want. This could leave you with less ambiguous code since you know what type of object is being initialized, but to make a change in your application's behaviour you would need to change your code.

In essence, the first option is less coupled than the second option, which is usually the recommended way of building things.

Answer 3

Well, the main difference is that in case u use @Autowired the object is also created, however, it's created by container and container decide when to do that. I want to give you a simple example: You have four classes 1,2,3 and 4. Three of them (1,2,3) uses the 4th. So, if you use new(), it`s hard to decide where to create object(in class 1, or 2, or 3, or even in each of them) of 4th class. Moreover, later you can delete class with object initialization and other 2 classes won't work (in case you created one object). Autowired annotation injects the object but you don't initialize object in class, so no problems appear This is like the simplest answer.

Answer 4

上面的答案很好，我想告诉他们之间的主要区别。自动装配的目的是，如果您要创建对象而又对一个类进行了更改，则避免类之间的依赖关系。