Annotation development

Why use annotations

To replace the heavy spring To configure bean, Annotations are widely used
Since this article only explains annotation development , So I won't show you the implementation of annotations , I will be in SpringBoot The implementation principle of annotation in the series

Spring Overview of common annotations

annotation	explain
@Component	Used on a class to instantiate Bean
@Controller	Use in web Layer class is used to instantiate Bean
@Service	Use in service Layer class is used to instantiate Bean
@Repository	Use in dao Layer class is used to instantiate Bean
@Autowired	Used on fields to inject depending on type dependency
@Qualifier	combination @Autowired— Used for dependency injection by name
@Resource	amount to @Autowired+@Qualifier, Inject by name
@Value	Inject common properties
@Scope	mark Bean Role model country
@PostConstruct	Use to mark the method on a method that is Bean How to destroy
@PreDestroy	Use to mark the method on a method that is Bean How to destroy

Spring Common overview of extended annotations

The use of the above annotations is not a complete substitute for xml The configuration file , You also need to use annotations to replace the configuration as follows

1. Non custom Bean Configuration of : <bean>
2. load properties Configuration of files :<contextproperty-placeholder>
3. Configuration of component scanning :<context:component-scan>
4. Introduce other files : <import>
5. etc.

annotation	explain
@Configuration	Used to specify that the current class is a Spring Configuration class , Annotations are loaded from this class when the container is created
@ComponentScan	Is used to specify the Spring The package to scan when initializing the container . Function and in Spring Of xml In the configuration file < context:component-scan base-package=“com.itheima”/ > equally
@Bean	Use it in a way , The annotation stores the return value of the method to Spring In the container
@PropertySource	Used for loading .properties Configuration in file
@lmport	Used to import other configuration classes
@Test	junit test

Annotation replaces

@Configuration Flag core configuration class

@Configuration
public class WebConfig implements WebMvcConfigurer {
    }

@ComponentScan Configure component scanning

Can replace

<context:component-scan base-package="com.example"></context:component-scan>

Sample code 1（ annotation + The configuration file ）

As soon as I use the annotation, I'm excited , After all, the fried chicken is cooked

Catalog

applicationContext.xml

The component scanning location needs to be configured in the configuration file

<!--     Configure component scanning -->
    <context:component-scan base-package="com.example"></context:component-scan>

Full configuration

<?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 https://www.springframework.org/schema/context/spring-context.xsd">

    <!--     Configure component scanning -->
 <context:component-scan base-package="com.example"></context:component-scan>
</beans>

baseMapper

among @Component(“baseMapper”) Instead of <bean id="baseMapper" class=" com.example.mapper.BaseMapper"></bean>

package com.example.mapper;

import org.springframework.stereotype.Component;

@Component("baseMapper")
public class BaseMapper {
    
    public void show() {
    
        System.out.println("baseMapper sout");
    }
}

baseService

package com.example.service;

public interface BaseService {
    
    void showBaseMapper();
}

baseServiceImpl

Of course you can use @Resource Instead of @Autowired and @Qualifier

package com.example.service.impl;

import com.example.mapper.BaseMapper;
import com.example.service.BaseService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.stereotype.Service;

@Service(value = "baseService")
public class BaseServiceImpl implements BaseService {
    

    @Autowired
    @Qualifier("baseMapper")
    private BaseMapper baseMapper;

    @Override
    public void showBaseMapper() {
    
        baseMapper.show();
    }
}

baseController

package com.example.controller;

import com.example.service.BaseService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.support.ClassPathXmlApplicationContext;
import org.springframework.stereotype.Controller;


public class BaseController {
    

    public static void main(String[] args) {
    
        ClassPathXmlApplicationContext app = new ClassPathXmlApplicationContext("applicationContext.xml");
        BaseService baseService = (BaseService) app.getBean("baseService");
        baseService.showBaseMapper();
    }
}

result

Corresponding relation （ important ）

Look at the lines of different colors, you should be able to understand

Sample code 2（ Pure annotation ！ I recommend this ）

I'll just list and sample code here 1 Different places

Catalog

Remove applicationContext.xml Component scan in

change to the use of sth. @ComponentScan("com.example") See below baseConfiguration

baseConfiguration

package com.example.configuration;

import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;

@Configuration
@ComponentScan("com.example")
public class BaseConfiguration {
    
}

baseController

Load configuration class

 AnnotationConfigApplicationContext app = new AnnotationConfigApplicationContext(BaseConfiguration.class);

package com.example.controller;

import com.example.configuration.BaseConfiguration;
import com.example.service.BaseService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;
import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.support.ClassPathXmlApplicationContext;
import org.springframework.stereotype.Controller;



public class BaseController {
    
    public static void main(String[] args) {
    
        AnnotationConfigApplicationContext app = new AnnotationConfigApplicationContext(BaseConfiguration.class);
        BaseService baseService = (BaseService) app.getBean("baseService");
        baseService.showBaseMapper();
    }

}

result

Corresponding relation

The previous correspondence is the same , here BaseConfiguration Instead of the sample code 1 in baseController Dependency profile correspondence