Bean s are ubiquitous in Spring and SpringMVC. It is important to internalize this concept. Here are my thoughts:
1, What is Bean
1. Java is object-oriented. Objects have methods and attributes, so object instances are required to call methods and attributes (that is, instantiation);
2. All classes with methods or attributes need to be instantiated, so that they can be visualized to use these methods and attributes;
3. Rule: all subclasses and classes with methods or attributes should be annotated to register beans to Spring IoC;
4. Understand a Bean as a proxy or spokesman of a class (in fact, it is implemented through reflection and proxy), so that it can represent that the class has what it should have
5. We have all @ so and so on the microblog. The other party will give priority to seeing this information and give you feedback. In Spring, if you identify an @ symbol, Spring will look at it and get a Bean or give a Bean from here
2, Annotations fall into two categories:
1. One is to use beans, that is, to use beans already configured in xml files to complete the assembly of attributes and methods; For example, @Autowired, @Resource can obtain beans through byTYPE (@Autowired) and byNAME (@Resource);
2. One is to register beans, @component, @repository, @ controller, @service, @configuration. These annotations convert the object you want to instantiate into a Bean and put it in the IoC container. When you need to use it, it will be combined with @autowired and @resource above to perfectly assemble objects, attributes and methods.
3, What is Bean?
1. What is the principle? First, let's take a look at some contents of the source code:
1 2 3 4 5 6 7 8 9 10 11 12 13 14 Indicates that a method produces a bean to be managed by the Spring container. <h3>Overview</h3> <p>The names and semantics of the attributes to this annotation are intentionally similar to those of the {@code <bean/>} element in the Spring XML schema. For example: <pre class="code"> @Bean public MyBean myBean() { // instantiate and configure MyBean obj return obj; }</pre>
It means that @Bean clearly indicates a method, and what method - generate a Bean method and hand it over to the Spring container for management; From this, we can see why @Bean is placed on the method annotation, because it clearly tells the annotated method that you will generate a Bean for me, and then give it to the Spring container. Leave the rest
2. Remember that @Bean is placed on the method, which is to generate a Bean. Are you confused again, because you have added @configuration and other annotations to the classes you define to register beans? Why use @Bean? I don't know. Let me give you an example and discuss it together:
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 package com.edu.fruit; //Define an interface public interface Fruit<T>{ //No method } /* *Define two subclasses */ package com.edu.fruit; @Configuration public class Apple implements Fruit<Integer>{//Constraining an Apple class to an Integer type } package com.edu.fruit; @Configuration public class GinSeng implements Fruit<String>{//Constraining the GinSeng class to a String type } /* *Business logic class */ package com.edu.service; @Configuration public class FruitService { @Autowired private Apple apple; @Autowired private GinSeng ginseng; //Define a method to generate beans @Bean(name="getApple") public Fruit<?> getApple(){ System.out.println(apple.getClass().getName().hashCode); System.out.println(ginseng.getClass().getName().hashCode); return new Apple(); } } /* *Test class */ @RunWith(BlockJUnit4ClassRunner.class) public class Config { public Config(){ super("classpath:spring-fruit.xml"); } @Test public void test(){ super.getBean("getApple");//Where does this Bean come from? From the methods below the @Bean above, return Is a Apple Class instance object } }
The above example also confirms the above summary:
1. All subclasses and classes with attributes and methods are registered in Spring and managed by it;
2. @Bean is used in the method to tell the Spring container that you can get a Bean from the following method