Bean The management of includes two aspects , One is to create Bean object , The second is to inject attributes , As explained in the previous section XML Mode management Bean, This section uses annotations to Bean Management of .

One 、 annotation

1. What is annotation ？
（1） Annotation is a special mark of code , Grammar format ：@ Annotated name ( The attribute name = Property value , The attribute name = Property value ..)
（2） Using annotations , Annotations work on classes , On the way , Attribute above
（3） The purpose of using annotations is ： simplify xml To configure
2.Spring Realization Bean Common notes on Management

name	effect
@Component	take Spring The classes in are marked as annotations , Can be used at any level （ Generally not used ）
@Repository	The data access layer （DAO layer ） The class ID of is Spring Medium Bean
@Service	The business layer （Service layer ） The class ID of is Spring Medium Bean
@Controller	Transfer control layer （Controller layer ） The class ID of is Spring Medium Bean
@Autowired	Yes Bean Property variable of 、 Attribute setter Method to mark , according to Bean Of type Transfer
@Resource	The functions and @Autowired equally , The difference is that @Resource The default in accordance with the Bean Of name Assembly ,@Resource There are two properties name and type,Spring take name Property resolved to Bean Instance name ,type Property resolved to Bean The instance type of
@Qualifier	Mark on the attribute , Perform attribute injection according to the attribute name
@Value	Mark on the attribute , Inject common properties

Two 、 Annotation management Bean

Use annotation to realize Bean Management of , We need to introduce... On the basis of the original aop Of jar package , The details are as follows 6 individual ：

Create objects and inject properties , The process is demonstrated as follows ：

//UserDao Interface 
public interface UserDao {
    
    public void say();
}

//UserService Interface 
public interface UserService {
    
    public void say();
}

//UserDao Implementation class of UserDaoImpl 
// Don't add value attribute , The default is the initial lowercase of the class name 
@Repository(value = "userDao")
public class UserDaoImpl implements UserDao {
    
    @Override
    public void say() {
    
        System.out.println("userDao say Hello World...");
    }
}

//UserService Interface implementation class UserServiceImpl 
@Service(value = "userService")
public class UserServiceImpl implements UserService {
    
    //@Resource(name = "userDao")
    @Autowired
    @Qualifier(value = "userDao")// Must cooperate @Autowired Can be used , If used alone, it will report an error ：NullPointerException
    private UserDao userDao;// When using annotation to inject attributes, you don't need setter Method 
    @Value(value = " To be alone ")// Use @Value Annotations inject common attributes 
    private String name;
    @Override
    public void say() {
    
        this.userDao.say();
        System.out.println("userService say Hello World...");
        System.out.println("name = "+name);
    }
}

The configuration file beans.xml

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:context="http://www.springframework.org/schema/context" xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd">
    <!-- Turn on annotation scanning , Need to use context Namespace , Pay attention to the configuration -->
    <!-- Turn on annotation scanning , here base-package The classes and attributes marked with annotations in the sub package under the attribute will be automatically Spring distinguish -->
    <!-- Turn on annotation scanning , If multiple packages are not under the same parent package , have access to “,” Separate multiple packages -->
    <context:component-scan base-package="com.jd.annotation"></context:component-scan>
</beans>

test ：

@Test
public void annTest(){
    
    ApplicationContext applicationContext = new ClassPathXmlApplicationContext("beans.xml");
    UserService userService = (UserService) applicationContext.getBean("userService");
    System.out.println(userService);
    userService.say();
}

Expand ：
In the above Spring In profile ,base-package The classes and properties under the package of attribute configuration will be scanned , In order to improve efficiency , You can set those that need to be scanned , Those that don't need scanning , As follows ：

The extension of knowledge ： Fully annotated development

Fully annotated development means that you don't need Spring The configuration file , Use configuration class instead of configuration file , As follows ：
（1） Write configuration classes , Instead of Spriing Configuration file for ;

// Configuration class , Function and above beans.xml Function the same 
@Configuration// As a configuration class , Alternative configuration file 
@ComponentScan(basePackages = {
    "com.jd.annotation"})
public class SpringConfig {
    
}

（2） Write the implementation class
The implementation class is the above UserDao Interface 、UserService Interface 、UserDao Implementation class UserDaoImpl and UserService Implementation class UserServiceImlp
（3） Test class

@Test
public void allAnnotationTest(){
    
	// After using annotation class , establish Spring When the container , Use AnnotationConfigApplicationContext(SpringConfig.class)
    ApplicationContext applicationContext = new AnnotationConfigApplicationContext(SpringConfig.class);
    UserService userService = (UserService) applicationContext.getBean("userService");
    System.out.println(userService);
    userService.say();
}

Fully annotated development can understand , The actual is Spring Boot Development , About Spring Boot The technical follow-up meeting will explain .