Spring 注解

超、凢脫俗 2021-09-18 04:14 490阅读 0赞

### Spring 注解学习 ###

demo 地址: https://github.com/abinbao/spring-annotations

#### 2019-01-01(打卡) ####

今天 spring 注解完成到 P10, 该完成 P11  
总结:  
Bean 的注入方式：

1）@Import  
可以快速的将bean注入到容器中，不需要 @Controller 等注解或者包扫描, bean id 默认是包全名

@Configuration
    @Import({ Color.class }) 
    public class MainConfigure {
    
    }

2）@ImportSelector  
可以返回一组需要导入的组件数组

package com.beng.condition;
    import org.springframework.context.annotation.ImportSelector;
    import org.springframework.core.type.AnnotationMetadata;
    // 自定义逻辑返回需要导入的组件
    public class MyImportselector implements ImportSelector {
        // AnnotationMetadata： 当前标注 @Import 注解类的所有注解信息
        public String[] selectImports(AnnotationMetadata importingClassMetadata) {
            // 方法不要返回null值
            return new String[] { "com.beng.model.Color", "com.beng.model.Red", "com.beng.model.Blue" };
        }
    }
    @Configuration
    @Import({ Color.class,MyImportselector.class }) 
    public class MainConfigure {
    
    }

3） @ImprtBeanDefinitionRegistrar

package com.beng.condition;
    import org.springframework.beans.factory.support.BeanDefinitionRegistry;
    import org.springframework.beans.factory.support.RootBeanDefinition;
    import org.springframework.context.annotation.ImportBeanDefinitionRegistrar;
    import org.springframework.core.type.AnnotationMetadata;
    import com.beng.model.RainBow;
    public class MyImprtBeanDefinitionRegistrar implements ImportBeanDefinitionRegistrar {
        // AnnotationMetadata 当前类的注解信息
        // BeanDefinitionRegistry 注册类
        // BeanDefinitionRegistry.registerBeanDefinition 手动注册
        public void registerBeanDefinitions(AnnotationMetadata importingClassMetadata, BeanDefinitionRegistry registry) {
            boolean flag = registry.containsBeanDefinition("com.beng.model.Red");
            if (flag) {
                // 指定 bean 的定义信息
                RootBeanDefinition rd = new RootBeanDefinition(RainBow.class);
                registry.registerBeanDefinition("rainBow", rd);
            }
        }
    }
    
    @Configuration
    @Import({ Color.class,MyImportselector.class,MyImprtBeanDefinitionRegistrar.class  }) 
    public class MainConfigure {
    
    }

#### 2019-01-02(打卡) ####

今天 spring 注解完成到 P15, 该完成 P16

总结:

补充上边 Bean 的注入方式：  
@FactoryBean 使用工厂bean  
默认获取工厂 bean getObject()创建的对象  
要获取工厂本身 需在 bean 前边加前缀 &

@Configuration
    public class MainConfigure {
    @Bean
        public ColorFactoryBean colorFactoryBean() {
            return new ColorFactoryBean();
        }
    }
    
    import org.springframework.beans.factory.FactoryBean;
    public class ColorFactoryBean implements FactoryBean<Color> {
    
        /**
         * 返回一个 Color 对象，注册到容器中
         */
        public Color getObject() throws Exception {
            return new Color();
        }
    
        public Class<?> getObjectType() {
            return Color.class;
        }
    
        /**
         * 返回 true bean 单实例 false 多实例
         */
        public boolean isSingleton() {
            return false;
        }
    
    }

Bean 的生命周期：

/*
     * bean 的生命周期：
     *  bean 的创建 - 初始化 - 销毁
     *  容器管理 bean 的生命周期
     *  自定义初始化和销毁方法，容器在执行bean生命周期时，调用初始化和销毁方法
     *  
     *  构建对象：
     *   单实例：容器启动时创建对象
     *   多实例：每次调用的时候创建对象
     *  初始化：
     *   对象创建完成，并赋值完成，调用初始化方法
     *  销毁：
     *   单实例，容器关闭的时候进行销毁
     *   多实例，容器不会管理这个bean，容器关闭不会调用销毁方法
     *   
     *  1） 指定初始化和销毁方法
     *      initMethod   destroyMethod
     *  
     *  2） 通过 Bean 实现 InitailizingBean（定义初始化逻辑）
     *                   DesposableBean（定义销毁逻辑）
     * 
     *  3） 使用注解 @PostConstruct Bean 创建完成，并且赋值完成
     *             @PreDestroy Bean 销毁之前调用
     *             
     *  4） BeanPostProcessor【interface】: bean 的后置处理器
     *     在 bean 的初始化前后做一些处理工作
     *     postProcessBeforeInitialization : 在 bean 的初始化之前
     *     postProcessAfterInitailization : 在初始化之后
     */
    @ComponentScan("com.beng.model")
    @Configuration
    public class MainConfigLifeCycle {
    
        // @Scope("prototype")
        @Bean(initMethod = "init", destroyMethod = "destroy")
        public Car car() {
            return new Car();
        }
    }
    ------------------------------------------------------------------------------------------------------
    public class Car {
        public Car() {
            System.out.println("Car is 初始化...");
        }
    
        public void init() {
            System.out.println("Car is initing...");
        }
    
        public void destroy() {
            System.out.println("Car is destroyed...");
        }
    }
    -------------------------------------------------------------------------------------------------------
    import org.springframework.beans.factory.DisposableBean;
    import org.springframework.beans.factory.InitializingBean;
    import org.springframework.stereotype.Component;
    @Component
    public class Cat implements InitializingBean, DisposableBean {
    
        public Cat() {
            System.out.println("Cat constructing...");
        }
    
        public void destroy() throws Exception {
            System.out.println("Cat destroying...");
        }
    
        public void afterPropertiesSet() throws Exception {
            System.out.println("Cat initing...");
        }
    }
    ---------------------------------------------------------------------------------------------------------
    import org.springframework.stereotype.Component;
    import javax.annotation.PostConstruct;
    import javax.annotation.PreDestroy;
    // 这种方式是在 java 1.5 是不行的
    @Component
    public class Dog {
        public Dog() {
            System.out.println("Dog constructing...");
        }
    
        @PreDestroy
        public void destroy() {
            System.out.println("Dog destroying...");
        }
    
        @PostConstruct
        public void init() {
            System.out.println("Dog initing...");
        }
    }
    ----------------------------------------------------------------------------------------------------------
    import org.springframework.beans.BeansException;
    import org.springframework.beans.factory.config.BeanPostProcessor;
    import org.springframework.stereotype.Component;
    /**
     * 将后置处理器加到容器中
     * 
     * @author apple
     */
    @Component
    public class MyBeanProcessor implements BeanPostProcessor {
    
        @Override
        public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
            System.out.println("postProcessBeforeInitialization..." + beanName + " ===> " + bean);
            return bean;
        }
    
        @Override
        public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
            System.out.println("postProcessAfterInitialization" + beanName + " ===> " + bean);
            return bean;
        }
    
    }

#### 2019-01-03(打卡) ####

今天 spring 注解完成到 P19, 该完成 P20

总结:

今天主要学习了 BeanPostProcessor 的原理和其在Spring中的使用，这一部分需要自己再去深入学习！！！！！！  
然后是 @Value 注解的学习，其主要有三种获取值得方式：

1.  基本数值
2.  spel \#\{\}
3.  $\{\} 取配置文件

示例代码：

Configure类：

import org.springframework.context.annotation.Bean;
    import org.springframework.context.annotation.Configuration;
    import org.springframework.context.annotation.PropertySource;
    import com.beng.model.Person;
    // 使用 @Propertysource 读取配置文件
    @PropertySource(value = "classpath:/person.properties")
    @Configuration
    public class MainConfigPropertyValue {
        @Bean
        public Person person() {
            return new Person();
        }
    }

model类：

public class Person {
    
        // 使用 @Value 赋值
        // 1. 基本数值
        // 2. spel #{}
        // 3. ${} 取配置文件
        @Value(value = "张三")
        private String username;
        @Value("#{20-2}")
        private int age;
        @Value("${nickname}")
        private String nickname;
        ···

配置文件：person.properties

nickname=zhangsan

单元测试类：

public class IocTest_PropertyValue {
    
        @Test
        public void test() {
            AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext(
                    MainConfigPropertyValue.class);
            System.out.println("容器创建完成...");
            String[] beans = context.getBeanDefinitionNames();
    
            ConfigurableEnvironment env = context.getEnvironment(); // 这里获取运行环境
            String property = env.getProperty("nickname"); // 获取运行环境中的变量
            System.out.println(property);
    
            Person person = (Person) context.getBean("person");
            System.out.println(person.toString());
            for (String name : beans) {
                System.out.println(name);
            }
            context.close();
        }
    }

#### 2019-01-05(打卡) ####

今天 spring 注解完成到 P23, 该完成 P24

感受:

今天主要学习了注解的自动注入，原来在做三方项目的时候就接触到了这个问题，当时不是很理解，学习了这个之后加深了对其的理解，也发现自身的很多的不足之处，其实对于 spring 的了解还知识皮毛，从了解，到使用，到熟悉其中很多的使用方式，以及如何去查询api，看官方文档，读源码等 ，都需要自己去深入学习。

总结：

日常应用的体验：

1.  @Autowired 注解，这个 spring 环境中，十分的实用。在一些业务场景中，可能会用到工厂方法模式，抽象出一个接口，不同的场景实现不同的功能，这个时候就可以使用@Autowired注解来给不同的业务场景注入不同的bean
2.  ApplicationContextAware 这个接口的使用，这个十分常用。通过实现这个接口，可以获得spring 底层的上下文组将，通过其可以获取容器中的一些对象，比如更改了某个bean的名称，就可以通过实现这个接口来提供一个根据bean的名称获取bean的方法 getBean(String beanname)b

今天的主要内容就是：

1）@Autowired spring的注解

2）@Qualifier 指定bean的id

3）@Primary 优先注入

4）@Resource java规范的注解

5）@Inject

1.  自定义组件实现 xxxAware 获得 spring 底层的组件

具体代码如下：

配置类：

import org.springframework.context.annotation.Bean;
    import org.springframework.context.annotation.ComponentScan;
    import org.springframework.context.annotation.Configuration;
    import org.springframework.context.annotation.Primary;
    
    import com.beng.dao.BookDao;
    import com.beng.model.Car;
    import com.beng.model.Color;
    
    /*
     * 自动装配：
     *  Spring 利用依赖注入，完成对IOC容器中各个组件的关系赋值
     *  1） @Autowired
     *      a. 默认有限按照类型从IOC容器中找对应的组件： context.getBean(BookDao.class)
     *      b. 如果找到多个相同类型的组件，再将属性的名称作为id去容器中查找
     *      c. @Qualifier("bookDao2")，指定需要装配的id，不适用属性名
     *      d. 自动装配默认一定要将属性赋值好，没有就报错
     *          @Autowired(required = false) 能装配就装配，不能就不装配
     *      e. @Primary, 让Spring进行自动装配的时候，默认首选的bean
     *          也可以继续使用Qualifier指定需要装配的名字 
     *  2） @Resource @Inject 【Java规范的注解】
     *          @Resource ：
     *              可以和@Autowired一样实现自动装配功能，默认按照组件名称进行装配
     *              @Resource(name="bookDao2") 没有支持 @Primary 和 @Autowired(require=false/true) 等功能
     *          @Inject ：
     *              需要导入 javax.inject 和 @Autowired 一样都能进行自动装配，@Autowired 内部有参数
     *  3） @Autowired : 构造器，参数，方法，属性，以上都是在属性位置标注
     *      a. 方法位置
     *      b. 构造器，如果组件只有一个有参构造器，参数构造器的 @Autowired 可以省略
     *      c. 参数位置
     *      
     *  4） 自定义组件想要使用 spring 底层的一些组件（ApplicationContext、BeanFactory、xxx）
     *          自定义组件 实现 xxxAware 接口 
     *          把Spring底层的一些组件注入到自定义的bean中
     * @author apple
     */
    @Configuration
    @ComponentScan({ "com.beng.service", "com.beng.dao", "com.beng.controller", "com.beng.model" })
    public class MainConfigAutowired {
    
        @Primary
        @Bean
        public BookDao bookDao() {
            return new BookDao();
        }
    
        /*
         * @Bean 标注的方法创建对象的时候，方法参数的值从容器中获取
         */
        @Bean
        public Color color(Car car) {
            Color color = new Color();
            color.setCar(car);
            return color;
        }
    
    }

model类：

import org.springframework.beans.factory.annotation.Autowired;
    import org.springframework.stereotype.Component;
    
    // 默认加载IOC容器中的组件，容器启动会调用无参构造器创建对象，再进行初始化赋值等操作
    @Component
    public class Boss {
    
        private Car car;
    
        // @Autowired
        public Boss(@Autowired Car car) {
            this.car = car;
            System.out.println("Boss 有参数构造器...");
        }
    
        public Car getCar() {
            return car;
        }
    
        // @Autowired
        // 标注在方法上，Spring 容器创建当前对象，就会调用该方法，进行赋值
        // 方法使用的参数，自定义类型的值从IOC容器中获取
        public void setCar(Car car) {
            this.car = car;
        }
    
        @Override
        public String toString() {
            return "Boss [car=" + car + "]";
        }
    
    }
    
    ---------------------------------------------------------------------------------------------------
    
    
    import org.springframework.beans.BeansException;
    import org.springframework.beans.factory.BeanNameAware;
    import org.springframework.context.ApplicationContext;
    import org.springframework.context.ApplicationContextAware;
    import org.springframework.context.EmbeddedValueResolverAware;
    import org.springframework.stereotype.Component;
    import org.springframework.util.StringValueResolver;
    
    @Component
    public class Red implements ApplicationContextAware, BeanNameAware, EmbeddedValueResolverAware {
    
        private ApplicationContext context;
    
        @Override
        public void setApplicationContext(ApplicationContext applicationContext) throws BeansException {
            System.out.println("传入的IOC ：" + applicationContext);
            this.context = applicationContext;
        }
    
        @Override
        public void setBeanName(String name) {
            System.out.println("当前bean的名字：" + name);
        }
    
        @Override
        public void setEmbeddedValueResolver(StringValueResolver resolver) {
            String str = resolver.resolveStringValue("你好,${os.name} ,我是 #{20*18}");
            System.out.println("解析的字符串：" + str);
    
        }
    
    }
    
    
    ---------------------------------------------------------------------------------------------------

测试类:

public class IocTest_Autowired {
    
        @Test
        public void test() {
    
            AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext(MainConfigAutowired.class);
    
            BookService service = context.getBean(BookService.class);
            System.out.println(service);
    
            BookDao dao = context.getBean(BookDao.class);
            System.out.println(dao);
    
            // String[] beans = context.getBeanDefinitionNames();
            // for (String name : beans) {
            // System.out.println(name);
            // }
    
            Boss boss = context.getBean(Boss.class);
            System.out.println(boss);
            Car car = context.getBean(Car.class);
            System.out.println(car);
            Color color = context.getBean(Color.class);
            System.out.println(color);
    
        }
    
    }

#### 2019-01-06(打卡) ####

今天 spring 注解完成到 P26, 该完成 P27

总结：  
今天主要学习的@Profile注解的学习，同时还复习了一下多天对于值得获取的使用，例如@Value。平时工作中对于Profile的使用基本是在pom文件中的使用或者是在properties文件中的使用，今天所学到的是在java代码中的使用。

例子主要以数据源进行举例，使用的c3p0数据源，maven中心仓库地址：https://mvnrepository.com

配置类:

import java.beans.PropertyVetoException;
    
    import javax.sql.DataSource;
    
    import org.springframework.beans.factory.annotation.Value;
    import org.springframework.context.EmbeddedValueResolverAware;
    import org.springframework.context.annotation.Bean;
    import org.springframework.context.annotation.Configuration;
    import org.springframework.context.annotation.Profile;
    import org.springframework.context.annotation.PropertySource;
    import org.springframework.util.StringValueResolver;
    
    import com.beng.model.Red;
    import com.mchange.v2.c3p0.ComboPooledDataSource;
    
    /*
     * Profile:
     *      Spring 为我们提供的介意根据当前环境，动态激活和切换组件的功能
     *   @Profile
     *      指定组件在那个环境中生效
     *      
     *  1) 加了环境标识的bean 只有环境被激活时，才会注册到容器中，默认是 default 环境
     *  2) 写在配置类上，只有是指定环境的时候，所有的配置才能生效
     *  3) 没有环境标志的bean，在任何环境下都会生效
     */
    
    @PropertySource("classpath:/dbconfig.properties")
    @Configuration
    @Profile("test")
    public class MainConfigProfile implements EmbeddedValueResolverAware {
    
        @Value("${db.user}")
        private String user;
    
        private StringValueResolver resolver;
    
        private String driverClass;
    
        // @Profile("test")
        @Bean
        public Red red() {
            return new Red();
        }
    
        @Profile("test")
        @Bean("testDatasource")
        public DataSource dataSourceTest(@Value("${db.password}") String pwd) throws PropertyVetoException {
            ComboPooledDataSource comboPooledDataSource = new ComboPooledDataSource();
            comboPooledDataSource.setUser(user);
            comboPooledDataSource.setPassword(pwd);
            comboPooledDataSource.setJdbcUrl("jdbc://mysql://localhost:3306/mydemo");
            driverClass = resolver.resolveStringValue("${db.driverClass}");
            comboPooledDataSource.setDriverClass(driverClass);
            return comboPooledDataSource;
        }
    
        @Profile("prod")
        @Bean("proDatasource")
        public DataSource dataSourcePro() throws PropertyVetoException {
            ComboPooledDataSource comboPooledDataSource = new ComboPooledDataSource();
            comboPooledDataSource.setUser("root");
            comboPooledDataSource.setPassword("123456");
            comboPooledDataSource.setJdbcUrl("jdbc://mysql://localhost:3306/mydemo");
            comboPooledDataSource.setDriverClass("com.mysql.jdbc.Driver");
            return comboPooledDataSource;
        }
    
        @Override
        public void setEmbeddedValueResolver(StringValueResolver resolver) {
            this.resolver = resolver;
        }
    }

测试类:

import javax.sql.DataSource;
    
    import org.junit.Test;
    import org.springframework.context.annotation.AnnotationConfigApplicationContext;
    
    import com.beng.configuration.MainConfigProfile;
    
    public class IocTest_Profile {
    
        /*
         * 1) 使用命令行动态参数 -Dspring.profiles.active=test 2) 代码方式激活环境
         */
        @Test
        public void test() {
    
            // AnnotationConfigApplicationContext context = new
            // AnnotationConfigApplicationContext(MainConfigProfile.class);
    
            // 1. 创建一个 ApplicationContext
            AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext();
            // 2. 设置需要激活的环境
            context.getEnvironment().setActiveProfiles("prod");
            // 3. 注册主配置类
            context.register(MainConfigProfile.class);
            // 4. 启动刷新容器
            context.refresh();
            String[] beans = context.getBeanDefinitionNames();
            for (String name : beans) {
                System.out.println(name);
            }
    
            String[] dataSources = context.getBeanNamesForType(DataSource.class);
            for (String name : dataSources) {
                System.out.println(name);
            }
        }
    
    }

pom.xml

<dependency>
    			<groupId>c3p0</groupId>
    			<artifactId>c3p0</artifactId>
    			<version>0.9.1.2</version>
    		</dependency>
    
    		
    		<dependency>
    			<groupId>mysql</groupId>
    			<artifactId>mysql-connector-java</artifactId>
    			<version>5.1.33</version>
    		</dependency>