Spring注解驱动

素颜马尾好姑娘i 2023-10-11 17:53 48阅读 0赞

## Spring注解驱动 ##

--------------------

> 作为复习把，来一次总结，方便以后SpringBoot的翻看

1.导入组件

@Component：普通组件
    
    @Service：service层
    
    @Repository：dao层
    
    @Controller：controller层（默认id为类名的小写驼峰）
    
    @Import：快速导入外部组件（默认id为全限定类名）
    
    @ImportResource(locations = {"classpath:application.xml"})：将以前的xml配置文件读取并应用
    
    FactoryBean：实现接口，用@Bean导入容器,导入的是工厂产生的类

2.java配置类相关注解

@Configuration：声明为配置类
    
    @Bean：返回值注册进容器
    
    @ComponentScan：扫描注册组件
    
    @WishlyConfiguration：@Configuration与@ComponentScan的组合注解

3.@Bean的属性支持

@Bean(initMethod = "",destroyMethod = "")
    
    @Scope 设置Spring容器如何新建Bean实例（方法上，得有@Bean）
    
    @Lazy：针对单例实现懒加载
    
    @PostConstruct：由JSR-250提供，bean的initMethod
    
    @PreDestory：由JSR-250提供，等价于bean的destroyMethod

4.注入bean的注解

@Autowired：由Spring提供，按类型装入
    
    @Qualifier：指定组件id，而不是按照类型注入
    
    @Primary：指定自动装配的首选
    
    @Inject：由JSR-330提供
    
    @Resource：由JSR-250提供，与@Autowired区别于按byName装入

5.@PropertySource和@Value注解

@Value("Howl")
    String name;
    
    @Value("#{systemProperties['os.name']}")
    String osName;
    
    @Value("#{ T(java.lang.Math).random() * 100 }") 
    String randomNumber;
    
    @Value("#{domeClass.name}")
    String name;
    
    @Value("classpath:com/hgs/hello/test.txt")
    String Resource file;
    
    @Value("http://www.cznovel.com")
    Resource url;
    
    // 使用外部配置文件，前提把配置文件加载到环境变量中
    Value("${book.name}")
    String bookName;
    
    @PropertySource 放在配置类上：读取properties外部配置文件K/V保存到运行的环境变量中，用${}取出
    @PropertySource("classpath:com/hgs/hello/test/test.propertie")

6.切面（AOP）相关注解

@Aspect：声明一个切面类
    
    @Before：前置通知
    
    @After：后置通知
    
    @AfterReturning：返回通知
    
    @AfterThrowing：异常通知
    
    @Around：在方法执行之前与之后执行
    
    @PointCut：声明切点 在java配置类中使用@EnableAspectJAutoProxy注解开启Spring对AspectJ代理的支持（类上）

7.环境切换

@Profile：通过设定配置环境
    
    @Conditional：实现Condition接口，从而决定该bean是否被实例化

8.异步相关

@EnableAsync：配置类中，通过此注解开启对异步任务的支持
    
    @Async：在实际执行的bean方法使用该注解来申明其是一个异步任务（方法上或类上所有的方法都将异步，需要@EnableAsync开启异步任务）

9.定时任务相关

@EnableScheduling：在配置类上使用，开启计划任务的支持
    
    @Scheduled：来申明这是一个任务，包括cron,fixDelay,fixRate等类型，使用cron表达式：每10秒执行

10.@Enable\*注解说明

这些注解主要用来开启对xxx的支持。
    
    @EnableAspectJAutoProxy：开启对AspectJ自动代理的支持
    
    @EnableAsync：开启异步方法的支持
    
    @EnableScheduling：开启计划任务的支持
    
    @EnableWebMvc：开启Web MVC的配置支持
    
    @EnableConfigurationProperties：开启对@ConfigurationProperties注解配置Bean的支持
    
    @EnableJpaRepositories：开启对SpringData JPA Repository的支持
    
    @EnableTransactionManagement：开启注解式事务的支持
    
    @EnableCaching：开启注解式的缓存支持

11.测试相关注解

@RunWith：运行器，Spring中通常用于对JUnit的支持
    @RunWith(SpringJUnit4ClassRunner.class)
    
    @ContextConfiguration：用来加载配置ApplicationContext，其中classes属性用来加载配置类
    @ContextConfiguration(classes={TestConfig.class})

12.补充

@EventListener：添加监听器，当然要注册进容器

13.SpringMVC部分

@EnableWebMvc：在配置类中开启Web MVC的配置支持
    
    @Controller：声明该类为SpringMVC中的Controller
    
    @ResponseBody：响应返回字符串
    
    @RestController：该注解为一个组合注解，相当于@Controller和@ResponseBody的组合
    
    @RequestMapping：用于映射Web请求，包括访问路径和参数（类或方法上）
    @GetMapping
    @PostMapping
    
    @RequestBody：请求发送json数据时，而参数在请求体中，而不是在url。那么该注解补充get方法只获取url参数的缺点，调用setter方法映射进对象中
    
    @PathVariable：用于接收路径参数，resful风格
    
    @CookieValue：放方法参数中，将映射到参数上
    
    @RequestParam：绑定请求中name属性相同的变量（使用了反射）
    
    @RestControllerAdvice
    @ControllerAdvice：该注解将对于控制器的全局配置放置在同一个位置。注解了@Controller的类的方法可使用@ExceptionHandler、@InitBinder、@ModelAttribute注解到方法上， 这对所有注解了@RequestMapping的控制器内的方法有效。
    
    结合下面的注解可实现：
    
    @ExceptionHandler：用于全局处理控制器里的异常
    
    @InitBinder：用来设置WebDataBinder，WebDataBinder用来自动绑定前台请求参数到Model中。
    
    @ModelAttribute：本来的作用是绑定键值对到Model里，在@ControllerAdvice中是让全局的@RequestMapping都能获得在此处设置的键值对。

14.springboot注解

@SpringBootApplication
    
    @EnableAutoConfiguration
    
    @SpringBootConfiguration
    
    @EnableConfigurationProperties：开启下面的功能
    
    @ConfigurationProperties(prefix="person")：需要下面的依赖
    其是@Value的升级版。注解类上，宽松批量注入属性，不像@Value一个个来书写注解

<dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-configuration-processor</artifactId>
    </dependency>

## 1. 组件注册 ##

*  包扫描+组件注解：@Component
 *  @Bean：导入第三方包里面的组件
 *  @Import：快速给[容器][Link 1]导入一个组件
 *  FactoryBean：实现接口注入容器

### 1.1 配置类上的基本注解 ###

@Configuration：声明当前类为配置类

@Bean：声明方法的**返回值**为一个bean，id默认是方法名

@ComponentScan：用于对Component进行扫描，里面有包含与排除规则

@Configuration
    @ComponentScan(value = {"com.howl.springannotation.controller","com.howl.springannotation.service"},
            excludeFilters = {
            @ComponentScan.Filter(type = FilterType.ANNOTATION,classes = Controller.class)
    })
    public class MainConfig {
    
        @Bean(value = "person01")
        public Person person(){
            return new Person("Howl",20);
        }
    }

### 1.2 @Bean的属性 ###

@Scope：设置Bean实例的作用域，默认单例（IOC容器启动会调用方法创建对象）

@Lazy：针对单实例实现懒加载

@Configuration
    public class MainConfig2 {
    
        @Bean
        @Scope(value = "singleton")
        @Lazy
        public Person person(){
            System.out.println("person was created");
            return new Person("Howl",20);
        }
    }

### 1.3 @Conditional ###

满足条件才注册bean，其接收Condition类的数组。而Condition是个接口，需要我们去实现。

**@Conditional可在方法上，也可在类上**

public class MyCondition implements Condition {
    
        /**
         * @param context：判断条件能使用的上下文环境
         * @param metadata：标注了@Conditional的注释信息
         * 参数是使用该类的地方帮我们传进去的
         * @return
         */
        @Override
        public boolean matches(ConditionContext context, AnnotatedTypeMetadata metadata) {
    //        context.getClassLoader();
    //        context.getBeanFactory();
    //        context.getClass();
    //        context.getRegistry();
    //        String os = context.getEnvironment().getProperty("os.name");
    //		  return os.contains("Windows");
            return false;
        }
    }

@Configuration
    public class MainConfig {
    
        @Bean
        @Conditional({MyCondition.class})
        public Person person01(){
            return new Person("Howl",20);
        }
    }

### 1.4 Import、ImportSelector、Registrar、FactoryBean ###

*  @Import(value = \{Person.class,User.class\})：直接写类，id默认全类名
 *  @Import(value = \{MyImportSelector.class\})：写ImportSelector实现类，id默认全类名
 *  @Import(value = \{MyImportBeanDefinitionRegistrar.class\})：手动注册bean
 *  FactoryBean：实现该接口，用@Bean注解导入该类，那么就会将其内部的类也加入容器。获取工厂可加前缀&

public class MyImportSelector implements ImportSelector {
    
        /**
         * @param importingClassMetadata：可获取注解类的所有注解信息
         * @return：返回值就是要导入的组件
         */
        @Override
        public String[] selectImports(AnnotationMetadata importingClassMetadata) {
            return new String[]{"com.howl.springannotation.bean.Student","com.howl.springannotation.bean.Worker"};
        }
    }

public class MyImportBeanDefinitionRegistrar implements ImportBeanDefinitionRegistrar {
    
        /**
         * @param importingClassMetadata：当前类的注解信息
         * @param registry：BeanDefinition的注册类
         */
        @Override
        public void registerBeanDefinitions(AnnotationMetadata importingClassMetadata, BeanDefinitionRegistry registry) {
            boolean teacher = registry.containsBeanDefinition("Teacher");
            if (!teacher) {
                RootBeanDefinition root = new RootBeanDefinition(Teacher.class);
                registry.registerBeanDefinition("Teacher", root);
            }
        }
    }

public class PersonFactoryBean implements FactoryBean<Person> {
    
        // 返回一个对象会添加到容器中
        @Override
        public Person getObject() throws Exception {
            return new Person();
        }
    
        @Override
        public Class<?> getObjectType() {
            return Person.class;
        }
    
        @Override
        public boolean isSingleton() {
            returnjava true;
        }
    }

@Configuration
    @Import(value = {User.class, MyImportSelector.class, MyImportBeanDefinitionRegistrar.class})
    public class MainConfig4 {
    
        @Bean
        public PersonFactoryBean personFactoryBean() {
            return new PersonFactoryBean();
        }
    }

## 2. 属性赋值 ##

*  @Value：
    
     *  基本数值
     *  SpEL \#\{\}
     *  配置文件 $\{\}

public class Person {
    
        @Value("Howl")
        private String name;
        @Value("${person.age}")
        private Integer age;
    
        // 。。。。
    }

@PropertySource(value = "classpath:person.properties")
    @Configuration
    public class MainConfig5 {
    
        @Bean
        public Person person(){
            return new Person();
        }
    
    }

## 3. 自动装配 ##

*  @Autowired：用AutowiredAnnotationBeanPostProcssor完成自动注入的
    
     *  放属性上
     *  放setter（方法）上：调用方法完成赋值，方法的参数从容器中获取
     *  放构造器上：默认的组件会调用无参构造器创建对象再进行初始化赋值等操作；若当前类只有一个有参构造器，那么@Autowired可以省略的（前提没有默认，否则首选默认）
     *  配置@Bean，那么方法参数可以自动注入而不用@Autowired
 *  XXXAware：自定义组件想要使用Spring容器底层的组件（ApplicationContext,BeanFactory），只需实现接口即可，在创建对象的时候，会调用接口规定的方法。其实也是setter方法参数自动注入

@Autowired
    BookService bookService;
    
    @Autowired
    public void setBookService(BookService bookService) {
        this.bookService = bookService;
    }
    
    @Autowired
    public BookController(BookService bookService) {
        this.bookService = bookService;
    }
    
    @Bean
    public BookController bookController(BookService bookService){
        return new BookController(bookService);
    }

## 4. 环境切换 ##

默认是default标识，但是下面代码三步执行，第二部就是加载配置文件，没有设置环境，所以得手动做这三步

AnnotationConfigApplicationContext ac = new AnnotationConfigApplicationContext(MainConfig7.class)

public AnnotationConfigApplicationContext(Class<?>... componentClasses) {
       this();
       register(componentClasses);		// 加载配置文件
       refresh();
    }

AnnotationConfigApplicationContext ac = new AnnotationConfigApplicationContext();
    ac.getEnvironment().setActiveProfiles("dev");
    ac.register(MainConfig7.class);
    ac.refresh();

## 5. Bean生命周期 ##

bean创建-----初始化-----销毁

一. 构造

*  单实例：容器启动时创建（调用构造器）
 *  多实例：每次获取时创建（调用构造器）

二.初始化

*  对象创建完成，并复赋值好后，调用初始化方法

三.销毁

*  单实例：容器关闭时调用
 *  多实例：容器不管理这个bean，GC来回收

**指定初始化和销毁方法：**

*  @Bean(initMethod = "init",destroyMethod = "destory")

**让Bean实现接口：**

*  InitializingBean
 *  DisposableBean

**JSR-250提供注解**

*  @PostConstruct
 *  @PreDestroy

**后置处理器：对每一个bean都有效**

*  BeanPostProcessor

public class Worker implements InitializingBean, DisposableBean {
    
        public Worker() {
            System.out.println("worker constructor");
        }
    
        @PostConstruct
        public void init(){
            System.out.println("worker init");
        }
    
        @PreDestroy
        public void destory(){
            System.out.println("worker destory");
        }
    
        @Override
        public void destroy() throws Exception {
            System.out.println("接口的销毁方法");
        }
    
        @Override
        public void afterPropertiesSet() throws Exception {
            System.out.println("接口的初始化方法");
        }
    }

public class MyBeanProcessor implements BeanPostProcessor {
        /**
         * @param bean：创建的实例
         * @param beanName：实例的名字
         * @return ：返回需要用到的实例，类似于@Bean
         * @throws BeansException
         */
        @Override
        public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
            System.out.println(bean + beanName + "---------内容呢额-----------");
            return bean;
        }
    
        @Override
        public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
            System.out.println(bean + beanName + "-----------内容呢额---------");
            return bean;
        }
    }

## 6. AOP ##

被切入的方法，切面类，各种通知、原理是动态代理

切面类：

@Aspect
    public class LogAspect {
    
        @AfterReturning(value = "execution(public void com.howl..*(..))", returning = "result")
        public int after(JoinPoint joinPoint, Object result) {
            System.out.println("前置通知" + joinPoint.getSignature().getName() + result);
            return 10;
        }
    }

配置类：重点在于开启注解

@EnableAspectJAutoProxy  // 开启切面注解
    @Configuration
    public class AopConfig {
    
        @Bean  // 注意Bean上的@Autowired是自动注入，可以不写的
        public LogAspect logAspect(JoinPoint joinPoint){
            return new LogAspect();
        }
    
        @Bean
        public TestService testService(){
            return new TestService();
        }
    }

## 7. 声明式事务 ##

// 1. 导入相关依赖
    // 2. 注册配置数据源
    // 3. 给需要事务的方法或类标注@Transactional
    // 4. 开启基于注解的事务管理功能 @EnableTransactionManagement
    // 5. 注册Spring平台的事务管理器来控制事务，重点他要管理数据源，才能管理每一条连接，才能管理事务
    @EnableTransactionManagement
    @Configuration
    public class DbConfig {
    
        @Bean
        public DataSource dataSource(){
            DriverManagerDataSource dataSource = new DriverManagerDataSource();
            dataSource.setUsername("root");
            dataSource.setPassword("root");
            dataSource.setDriverClassName("com.mysql.jdbc.Driver");
            dataSource.setUrl("jdbc:mysql://localhost:3306/test");
            return dataSource;
        }
    
        // 可以放参数上，那样会自动注入Bean对象
        // 或调用方法，配置类中的方法调用会被认为是依赖注入
        @Bean
        public PlatformTransactionManager transactionManager(DataSource dataSource){
            return new DataSourceTransactionManager(dataSource());
        }
    }

## 8. 监听器 ##

用在方法上，当然这个类要加入进容器才行

public class test {
    
        @EventListener(classes = {ApplicationEvent.class})
        public void evenListener(ApplicationEvent event){
            System.out.println("注解下的监听器");
        }
    }

## 9. @ConfigurationProperties的使用 ##

*  编写properties文件
 *  编写properties类，类上加注解来宽松匹配
 *  配置类上开启宽松匹配功能，并导入properties文件进环境

student.name=howl
    student.age=20

@ConfigurationProperties(prefix = "student")
    // @Component
    public class StudentProperties {
    
        private String name;
        private int age;
    
    	// 利用setter方法注入
    }

@EnableConfigurationProperties
    @PropertySource("classpath:application.properties")
    @Configuration
    public class MainConfig10 {
    
        @Bean
        public Student student(){
            return new Student();
        }
    }

[Link 1]: https://cloud.tencent.com/product/tke?from=10680