spring常用注解说明

SSM

spring-mybatis.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"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
       http://www.springframework.org/schema/beans/spring-beans.xsd
       http://www.springframework.org/schema/aop
       http://www.springframework.org/schema/aop/spring-aop.xsd
       http://www.springframework.org/schema/context
       http://www.springframework.org/schema/context/spring-context.xsd
       http://www.springframework.org/schema/tx
       http://www.springframework.org/schema/tx/spring-tx.xsd "
       xmlns:context="http://www.springframework.org/schema/context"
       xmlns:tx="http://www.springframework.org/schema/tx"
       xmlns:aop="http://www.springframework.org/schema/aop"
       default-autowire="byName" ><!--按照名字自动注入,默认是按照name自动注入-->
​
​
    <!--引入jdbc.properities-->
    <context:property-placeholder location="classpath:jdbc.properties"/>
​
1 、扫描实现类的注解（@Autowired、@service等）
    <!--扫描实现类注解！！springmvc扫描的是controller的注解-->
    <context:component-scan base-package="com.service.impl"/>
​
2 、配置数据源
    <!--数据源-->
    <bean id="dataSource" class="org.springframework.jdbc.datasource.DriverManagerDataSource">
        <property value="com.mysql.jdbc.Driver" name="driverClassName"/>
        <property value="jdbc:mysql://localhost:3306/rbac" name="url"/>
        <property value="root" name="username"/>
        <property value="123456" name="password"/>
        <!--配置数据库连接池的其他属性<property name="maxPoolSize" value="${c3p0.maxPoolSize}"/>
            <property name="minPoolSize" value="${c3p0.minPoolSize}"/>
            <property name="autoCommitOnClose" value="${c3p0.autoCommitOnClose}"/>
            <property name="checkoutTimeout" value="${c3p0.checkoutTimeout}"/>
            <property name="acquireRetryAttempts" value="${c3p0.acquireRetryAttempts}"/>-->
    </bean>
​
​
3 、由数据源、mapper.xml文件配置sqlSessionFactory产生工厂对象。（可在该处配置别名）
    <!-- SqlSessinFactory对象 结合数据库、pojo、mapper.xml文件，由工厂生成数据库对象-->
    <bean id="sqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean">
        <property name="dataSource" ref="dataSource"/>
        <!-- 为pojo的实体类配置别名 -->
        <property name="typeAliasesPackage" value="com.pojo"/>
        <!--扫描mapper.xml文件-->
        <property name="mapperLocations" value="classpath:mapper/*.xml"/>
    </bean>
​
​
4 、扫描dao层，由上面工厂对象结合dao层接口产生实际接口对象
    <!--扫描器扫描dao层  由上面的数据库对象和dao层接口-->
    <bean class="org.mybatis.spring.mapper.MapperScannerConfigurer">
        <property name="basePackage" value="com.dao"/>
        <property name="sqlSessionFactoryBeanName" value="sqlSessionFactory"/>
    </bean>
​
5 、配置事务
    <!-- 定义事务管理器 -->
    <bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
        <property name="dataSource" ref="dataSource"/>
    </bean>
    <!-- 事务的隔离性，事务的传播行为 -->
    <!-- 定义事务策略 -->
    <tx:advice id="txAdvice" transaction-manager="transactionManager">
        <tx:attributes>
            <!--所有以query开头的方法都是只读的 -->
            <tx:method name="query*" read-only="true"/>
            <tx:method name="get*" read-only="true"/>
            <tx:method name="find*" read-only="true"/>
            <tx:method name="select*" read-only="true"/>
            <!--其他方法使用默认事务策略 -->
            <tx:method name="*"/>
        </tx:attributes>
    </tx:advice>
​
    <aop:config>
        <!--pointcut元素定义一个切入点，execution中的第一个星号 用以匹配方法的返回类型， 这里星号表明匹配所有返回类型。 com.abc.dao.*.*(..)表明匹配cn.itcast.mybatis.service包下的所有类的所有  方法 -->
        <aop:pointcut id="myPointcut" expression="execution(* com.service.*.*(..))"/>
        <!--将定义好的事务处理策略应用到上述的切入点 -->
        <aop:advisor pointcut-ref="myPointcut" advice-ref="txAdvice"/>
        <!--使用XML配置启用@AspectJ支持，还有另一个方法是要使用Java @Configuration启用@AspectJ支持（配置类注释），请添加@EnableAspectJAutoProxy注释-->
        <!--<aop:aspectj-autoproxy/>-->
    </aop:config>

springmvc.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:mvc="http://www.springframework.org/schema/mvc"
       xmlns:context="http://www.springframework.org/schema/context"
       xmlns:aop="http://www.springframework.org/schema/aop"
       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
       http://www.springframework.org/schema/mvc
       http://www.springframework.org/schema/mvc/spring-mvc.xsd http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop.xsd">
​
    1 、扫描控制层下的注解，并设置注解驱动
    <!--扫描controller包的注解-->
    <context:component-scan base-package="com.controller"/>
    <!--注解驱动-->
    <mvc:annotation-driven></mvc:annotation-driven>
    
    2 、配置静态资源
    <!--静态资源-->
    <!-- MultipartResovler解析器 自动识别相应的静态文件 -->
    <mvc:default-servlet-handler/>
    
    3 、配置异常解析器
    <!-- 异常解析器 -->
    <bean id="exceptionResolver" class="org.springframework.web.servlet.handler.SimpleMappingExceptionResolver">
        <property name="exceptionMappings">
            <props>
                <prop key="org.springframework.web.multipart.MaxUploadSizeExceededException">/error.jsp</prop>
            </props>
        </property>
    </bean>
</beans>

spring-mybatis中主要分5步：

扫描实现类的注解-------配置数据源---------由数据源、mapper.xml文件配置sqlSessionFactory产生工厂对象-------

----------由上面工厂对象结合dao层接口产生实际接口对象--------事务配置

springmvc中配置主要：

扫描控制层并设置注解驱动---------配置静态资源（如前后端分离可不用）---------配置异常解析器

 

 

纯注解版spring

 

1 、用纯注解代替bean.xml 即将在xml中设置bean的操作用注解代替 @bean

创建配置类config，代替原来的bean.xml文件
@Configuration   //告诉spring这是一个配置类
public class MiConfig {
    @bean //向容器中注册一个Bean；类型为返回值类型，id默认为方法名id
    public Person person(){
        return new Person("lisi", 20); 
    }
}
​
也可指定名称：@bean("名字")
​
例如以上面的配置类为主配置类，读取主配置类方式获取ioc容器（spring容器自动启动也可通过主配置类开启）
xml方式：new ClassPathXmlApplicationContext("xml文件")
config方式： new AnnotationConfigApplicationContext(主配置类.class)

2 、扫描注解@ComponentScan

<context:component-scan base-package="包名"/>
  注解扫描，只要标注了@controller @Service @Repository @Compent 的组件都会被自动扫描加到容器中
  
注解版：在主配置类中加上：@ComponentScan(value = "要扫描的包")即可
       还要其他参数例：1）excludeFilters = {@Filter{type=FilterType.ANNOTATION，classes={Controller.class,Service.class}}}   即可过滤Controller和Service标注的组件，ANNOTATION为注解方式也可其他方式（正则，不同类型，自定义等方式）
        2）includeFilter则是只包含
    
也可用@ComponentScans{value = {多个@ComonentScan}}

3 、注入的对象的作用范围 @Scope

@Scope("prototype/singleton/request/session")//参数可以是其中一个，默认值是singleton
//prototype 多实例，ioc容器启动并不会调用方法创建对象放在容器中以备之后调用时用，而是在  //每次获取的时候调用方法创建对象（即前后所获取的对象不==）
//singleton 单实例，ioc容器会在启动时调用方法创建对象放在ioc容器中，之后每次获取都是直接 //   从容器中拿（map.get()）(即每次的对象都是相等的)
//request 同一次请求创建一个实例
//session 同一个session创建一个实例
@Bean("person") //向容器中注册一个Bean；类型为返回值类型，id默认为方法名id
public Person person(){
    return new Person("lisi", 20); 
}

4 、懒加载@Lazy

单实例bean，默认在容器启动时创建对象。
懒加载即在容器启动时不创建对象，而在第一次使用（获取）Bean时创建对象并初始化。（可减少一些实际没调用到的bean，减少开销）
加上@Lazy即可

5 、 @Conditional ，按照一定的条件进行判断，满足条件则给容器进行注册bean

/**   
     * @Conditional({Condition}) ： 按照一定的条件进行判断，满足条件给容器中注册bean
     例子： 
     * 如果系统是windows，给容器中注册("bill")
     * 如果是linux系统，给容器中注册("linus")
*/
    @Conditional(WindowsCondition.class)
    @Bean("bill")
    public Person person01(){
        return new Person("Bill Gates",62);
    }
    @Conditional(LinuxCondition.class)
    @Bean("linus")
    public Person person02(){
        return new Person("linus", 48);
    }
---------------------------------------------------
//判断是否windows系统
public class WindowsCondition implements Condition {
    @Override
    public boolean matches(ConditionContext context, AnnotatedTypeMetadata metadata) {
        Environment environment = context.getEnvironment();
        String property = environment.getProperty("os.name");
        if(property.contains("Windows")){
            return true;
        }
        return false;
    }
}
-------------------------------------------------
//判断是否linux系统
public class LinuxCondition implements Condition {
    /**
     * ConditionContext：判断条件能使用的上下文（环境）
     * AnnotatedTypeMetadata：注释信息
     */
    @Override
    public boolean matches(ConditionContext context, AnnotatedTypeMetadata metadata) {
        // TODO是否linux系统
        //1、能获取到ioc使用的beanfactory
        ConfigurableListableBeanFactory beanFactory = context.getBeanFactory();
        //2、获取类加载器
        ClassLoader classLoader = context.getClassLoader();
        //3、获取当前环境信息
        Environment environment = context.getEnvironment();
        //4、获取到bean定义的注册类
        BeanDefinitionRegistry registry = context.getRegistry();
        String property = environment.getProperty("os.name");
        //可以判断容器中的bean注册情况，也可以给容器中注册bean
        boolean definition = registry.containsBeanDefinition("person");
        if(property.contains("linux")){
            return true;
        }
        return false;
    }
}
​
@Conditional不仅可以放在方法前也可放在类前，放在类前表示所有方法都遵循该条件1

6 、@Import 快速导入组件 、 注册组件的方法

/**
     * 给容器中注册组件；
     * 1）、包扫描+组件标注注解（@Controller/@Service/@Repository/@Component）[自己写的类]
     * 2）、@Bean[导入的第三方包里面的组件]
     * 3）、@Import[快速给容器中导入一个组件]
     *      1）、@Import(要导入到容器中的组件)；容器中就会自动注册这个组件，id默认是全类名
     *      2）、ImportSelector:返回需要导入的组件的全类名数组；
     *      3）、ImportBeanDefinitionRegistrar:手动注册bean到容器中
     * 4）、使用Spring提供的 FactoryBean（工厂Bean）;
     *      1）、默认获取到的是工厂bean调用getObject创建的对象
     *      2）、要获取工厂Bean本身，我们需要给id前面加一个&
     *          &colorFactoryBean
     */
可在类前导入，导入的可以是组件数组@Import({A.class , B.class})
    
    
 -------------------------------
ImportSeletctor:
//自定义逻辑返回需要导入的组件
public class MyImportSelector implements ImportSelector {
    //返回值，就是到导入到容器中的组件全类名
    //AnnotationMetadata:当前标注@Import注解的类的所有注解信息
    @Override
    public String[] selectImports(AnnotationMetadata importingClassMetadata) {
        // TODO Auto-generated method stub
        //importingClassMetadata
        //方法不要返回null值
        return new String[]{"com.atguigu.bean.Blue","com.atguigu.bean.Yellow"};
    }
}
----------------------------------------------
 ImportBeanDefinitionRegistrar :
 public class MyImportBeanDefinitionRegistrar implements ImportBeanDefinitionRegistrar {
    /**
     * AnnotationMetadata：当前类的注解信息
     * BeanDefinitionRegistry:BeanDefinition注册类；
     *      把所有需要添加到容器中的bean；调用
     *      BeanDefinitionRegistry.registerBeanDefinition手工注册进来
     */
    @Override
    public void registerBeanDefinitions(AnnotationMetadata importingClassMetadata, BeanDefinitionRegistry registry) {
        
        boolean definition = registry.containsBeanDefinition("com.atguigu.bean.Red");
        boolean definition2 = registry.containsBeanDefinition("com.atguigu.bean.Blue");
        if(definition && definition2){
            //指定Bean定义信息；（Bean的类型，Bean。。。）
            RootBeanDefinition beanDefinition = new RootBeanDefinition(RainBow.class);
            //注册一个Bean，指定bean名
            registry.registerBeanDefinition("rainBow", beanDefinition);
        }
    }
}
----------------------------------
  1 、创建生产对象的工厂
    //创建一个Spring定义的FactoryBean
public class ColorFactoryBean implements FactoryBean<Color> {
    //返回一个Color对象，这个对象会添加到容器中
    @Override
    public Color getObject() throws Exception {
        // TODO Auto-generated method stub
        System.out.println("ColorFactoryBean...getObject...");
        return new Color();
    }
    @Override
    public Class<?> getObjectType() {
        // TODO Auto-generated method stub
        return Color.class;
    }
    //是单例？
    //true：这个bean是单实例，在容器中保存一份
    //false：多实例，每次获取都会创建一个新的bean；
    @Override
    public boolean isSingleton() {
        // TODO Auto-generated method stub
        return false;
    }
}
​
​
2 、再向容器注册工厂组件，每次工厂产生的bean都是通过getObject获取的
    @Bean
    public ColorFactoryBean colorFactoryBean(){
        return new ColorFactoryBean();
    }

7 、bean的生命周期

/**
 * bean的生命周期：
 *      bean创建---初始化----销毁的过程
 * 容器管理bean的生命周期；
 * 我们可以自定义初始化和销毁方法；容器在bean进行到当前生命周期的时候来调用我们自定义的初始化和销毁方法
 * 
 * 构造（对象创建）
 *      单实例：在容器启动的时候创建对象
 *      多实例：在每次获取的时候创建对象\
 * 
 * BeanPostProcessor.postProcessBeforeInitialization
 * 初始化：
 *      对象创建完成，并赋值好，调用初始化方法。。。
 * BeanPostProcessor.postProcessAfterInitialization
 * 销毁：
 *      单实例：容器关闭的时候
 *      多实例：容器不会管理这个bean；容器不会调用销毁方法；
 * 
 * 原理：
 * 遍历得到容器中所有的BeanPostProcessor；挨个执行beforeInitialization，
 * 一但返回null，跳出for循环，不会执行后面的BeanPostProcessor.postProcessorsBeforeInitialization
 * 
 * BeanPostProcessor原理
 * populateBean(beanName, mbd, instanceWrapper);给bean进行属性赋值
 * initializeBean
 * {
 * applyBeanPostProcessorsBeforeInitialization(wrappedBean, beanName);
 * invokeInitMethods(beanName, wrappedBean, mbd);执行自定义初始化
 * applyBeanPostProcessorsAfterInitialization(wrappedBean, beanName);
 *}
 * 
 * 
 * 
 * 1）、指定初始化和销毁方法；
 *      通过@Bean指定init-method和destroy-method；
 * 2）、通过让Bean实现InitializingBean（定义初始化逻辑），
 *              DisposableBean（定义销毁逻辑）;
 * 3）、可以使用JSR250；
 *      @PostConstruct：在bean创建完成并且属性赋值完成；来执行初始化方法
 *      @PreDestroy：在容器销毁bean之前通知我们进行清理工作
 * 4）、BeanPostProcessor【interface】：bean的后置处理器；
 *      在bean初始化前后进行一些处理工作；
 *      postProcessBeforeInitialization:在初始化之前工作
 *      postProcessAfterInitialization:在初始化之后工作
 * 
 * Spring底层对 BeanPostProcessor 的使用；
 *      bean赋值，注入其他组件，@Autowired，生命周期注解功能，@Async,xxx BeanPostProcessor;
 * 
 * @author lfy
 *
 */
@ComponentScan("com.atguigu.bean")
@Configuration
public class MainConfigOfLifeCycle {
    
    //@Scope("prototype")
    @Bean(initMethod="init",destroyMethod="detory")
    public Car car(){
        return new Car();
    }
}
​
----------------------
 1）、指定初始化和销毁方法；
 * 通过@Bean指定init-method和destroy-method；
   //@Component是把类注册到容器  ，@Bean是把方法注册到容器中
1 、在配置类中注入容器
@Configuration
public class MainConfigOfLifeCycle {
    //@Scope("prototype")当为多实例时调用时创建，销毁不由容器销毁由自己销毁
    @Bean(initMethod="init",destroyMethod="detory")
    public Car car(){
        return new Car();
    }
}
2 、写对应的car类
public class Car {
    public Car(){
        System.out.println("car constructor...");
    }
    public void init(){
        System.out.println("car ... init...");
    }
    public void detory(){
        System.out.println("car ... detory...");
    }
}
------------------------
 2）、通过让Bean实现InitializingBean（定义初始化逻辑），
 *  DisposableBean（定义销毁逻辑）;
实现上面的接口定义相应的逻辑
 @Component
 public class Cat implements InitializingBean,DisposableBean {
    public Cat(){
        System.out.println("cat constructor...");
    }
    @Override
    public void destroy() throws Exception {
        // TODO Auto-generated method stub
        System.out.println("cat...destroy...");
    }
    @Override
    public void afterPropertiesSet() throws Exception {
        // TODO Auto-generated method stub
        System.out.println("cat...afterPropertiesSet...");
    }
}
​
上面用Component在其他类中注册组件（前面的car是在配置类中用@Bean注册的所以不用扫描）
（@ComonentScan只能扫描@controller @Service @Repository @Compent，所以只能在配置类中用@Bean对方法组件进行注册??？？）
则在配置类中对其进行扫描
@ComonentScan("cat所在的包名")
@Configuration
public class MainConfigOfLifeCycle {
    //@Scope("prototype")当为多实例时调用时创建，销毁不由容器销毁由自己销毁
    @Bean(initMethod="init",destroyMethod="detory")
    public Car car(){
        return new Car();
    }
}
​
---------------------------------------------
 3）、可以使用JSR250；
 *      @PostConstruct：在bean创建完成并且属性赋值完成；来执行初始化方法
 *      @PreDestroy：在容器销毁bean之前通知我们进行清理工作
 @Component
public class Dog implements ApplicationContextAware {
    //@Autowired
    private ApplicationContext applicationContext;
    public Dog(){
        System.out.println("dog constructor...");
    }
    //对象创建并赋值之后调用
    @PostConstruct
    public void init(){
        System.out.println("Dog....@PostConstruct...");
    }
    //容器移除对象之前
    @PreDestroy
    public void detory(){
        System.out.println("Dog....@PreDestroy...");
    }
    @Override
    public void setApplicationContext(ApplicationContext applicationContext) throws BeansException {
        // TODO Auto-generated method stub
        this.applicationContext = applicationContext;
    }
}
要在配置类中扫描该组件，由于和cat放在同一个包，所以不用重复写
​
------------------------------
4）、BeanPostProcessor【interface】：bean的后置处理器；
 *      在bean初始化前后进行一些处理工作；
 *      postProcessBeforeInitialization:在创建后初始化之前工作
 *      postProcessAfterInitialization:在初始化之后销毁之前工作
 
 /**
 * 后置处理器：初始化前后进行处理工作
 * 将后置处理器加入到容器中
 * @author lfy
 */
@Component
public class MyBeanPostProcessor implements BeanPostProcessor {
​
    @Override
    public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
        // TODO Auto-generated method stub
        System.out.println("postProcessBeforeInitialization..."+beanName+"=>"+bean);
        return bean;
    }
​
    @Override
    public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
        // TODO Auto-generated method stub
        System.out.println("postProcessAfterInitialization..."+beanName+"=>"+bean);
        return bean;
    }
}
扫描该组件 
    
​

8 、属性赋值 @Value

在实体类中用@Value("")进行赋值
//使用@Value赋值；
    //1、基本数值
    //2、可以写SpEL； #{}
    //3、可以写${}；取出配置文件【properties】中的值（在运行环境变量里面的值）
    //要先在配置类使用@PropertySource(value={"classpath:路径"})加载文件，读取外部配置1文件中的K/V保存的运行的环境变量中，之后则可用${}提取
    @Value("张三")
    private String name;
    @Value("#{20-2}")
    private Integer age;
    @Value("${person.nickName}")
    private String nickName;
​

9 、 依赖注入（自动装配）@Autowired 、 @Resource 、等

/**
 * 自动装配;
 *      Spring利用依赖注入（DI），完成对IOC容器中中各个组件的依赖关系赋值；
 * 
 * 1）、@Autowired：自动注入：
 *      1）、默认优先按照类型去容器中找对应的组件:applicationContext.getBean(BookDao.class);找到就赋值
 *      2）、如果找到多个相同类型的组件，再将属性的名称作为组件的id去容器中查找
 *                          applicationContext.getBean("bookDao")
  多个相同类型组件时：默认是按类型取找组件的，如找到多个再按照组件名去找（@Bean没写value默认组件名是类名小写，有写则组件名为其value）
 *      3）、@Qualifier("bookDao")：使用@Qualifier指定需要装配的组件的id，而不是使用属性名（属性名即value）
 *      4）、自动装配默认一定要将属性赋值好，没有就会报错；
 *          可以使用@Autowired(required=false);则能自动注入就注入，不能自动注入则为null，不会报错。
 *      5）、@Primary：让Spring进行自动装配的时候，默认使用首选的bean；(即被修饰的bean会优先装配)
 *              也可以继续使用@Qualifier指定需要装配的bean的名字
 *      BookService{
 *          @Autowired
 *          BookDao  bookDao;
 *      }
 * 
 * 2）、Spring还支持使用@Resource(JSR250)和@Inject(JSR330)[java规范的注解]
 *      @Resource:
 *          可以和@Autowired一样实现自动装配功能；默认是按照组件名称进行装配的；
 *          没有能支持@Primary功能没有支持@Autowired（reqiured=false）;
 *      @Inject:
 *          需要导入javax.inject的包，和Autowired的功能一样。没有required=false的功能；
 *  @Autowired:Spring定义的； @Resource、@Inject都是java规范
 *  
 * AutowiredAnnotationBeanPostProcessor:解析完成自动装配功能； 
 ------------------------
 * 
 * 3）、 @Autowired:构造器，参数，方法，属性；都是从容器中获取参数组件的值（一般默认不写）
 *      1）、[标注在方法位置]：用@Bean+方法参数在配置类注册组件时；参数从容器中获取;默认不写@Autowired效果是一样的；都能自动装配
 *      2）、[标在构造器上]：如果组件只有一个有参构造器，这个有参构造器的@Autowired可以省略，参数位置的组件还是可以自动从容器中获取
 *      3）、放在参数位置：参数从容器中获取;默认不写@Autowired效果是一样的；都能自动装配
 
 //默认加在ioc容器中的组件，容器启动会调用无参构造器创建对象，再进行初始化赋值等操作
@Component
public class Boss {
    private Car car;
    //放在参数位置
    //public Boss(@AutoWired Car car){
    //  this.car = car;
    //  System.out.println("Boss...有参构造器");
    //}
    
    //构造器要用的组件，都是从容器中获取
    //@AutoWired 
    public Boss(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 + "]";
    }
}
 ----------------------
 * 
 * 4）、自定义组件想要使用Spring容器底层的一些组件（ApplicationContext，BeanFactory，xxx）；
 *      自定义组件实现xxxAware；在创建对象的时候，会调用接口规定的方法注入相关组件；Aware；
 *      把Spring底层一些组件注入到自定义的Bean中；
 *      xxxAware：功能使用xxxProcessor；
 *          ApplicationContextAware==》ApplicationContextAwareProcessor；
 *  
 *      
 * @author lfy
 *
 */
@Component
public class Red implements ApplicationContextAware,BeanNameAware,EmbeddedValueResolverAware {
    
    private ApplicationContext applicationContext;
    @Override
    public void setApplicationContext(ApplicationContext applicationContext) throws BeansException {
        // TODO Auto-generated method stub
        System.out.println("传入的ioc："+applicationContext);//ioc容器
        this.applicationContext = applicationContext;
    }
​
    @Override
    public void setBeanName(String name) {
        // TODO Auto-generated method stub
        System.out.println("当前bean的名字："+name);
    }
​
    @Override
    public void setEmbeddedValueResolver(StringValueResolver resolver) {
        // TODO Auto-generated method stub
        String resolveStringValue = resolver.resolveStringValue("你好 ${os.name} 我是 #{20*18}");
        System.out.println("解析的字符串："+resolveStringValue);
    }
}
​
​
-----------------------
@Configuration
@ComponentScan({"com.atguigu.service","com.atguigu.dao",
    "com.atguigu.controller","com.atguigu.bean"})
public class MainConifgOfAutowired {
    
    @Primary
    @Bean("bookDao2")
    public BookDao bookDao(){
        BookDao bookDao = new BookDao();
        bookDao.setLable("2");
        return bookDao;
    }
    
    /**
     * @Bean标注的方法创建对象的时候，方法参数的值从容器中获取
     * @param car
     * @return
     */
    @Bean
    public Color color(Car car){
        Color color = new Color();
        color.setCar(car);
        return color;
    }
}

10 、@Profile

------------
profile 
    /**
 * Profile：
 *      Spring为我们提供的可以根据当前环境，动态的激活和切换一系列组件的功能；
 * 
 * 开发环境、测试环境、生产环境；
 * 数据源：(/A)(/B)(/C)；
 * 
 * 
 * @Profile：指定组件在哪个环境的情况下才能被注册到容器中，不指定，任何环境下都能注册这个组件
 * 
 * 1）、加了环境标识的bean，只有这个环境被激活的时候才能注册到容器中。默认是default环境
 * 2）、写在配置类上，只有是指定的环境的时候，整个配置类里面的所有配置才能开始生效
 * 3）、没有标注环境标识的bean在，任何环境下都是加载的；
 */
​
@PropertySource("classpath:/dbconfig.properties")
@Configuration
public class MainConfigOfProfile implements EmbeddedValueResolverAware{
    
    @Value("${db.user}")
    private String user;
    
    private StringValueResolver valueResolver;
    private String  driverClass;
    
    @Bean
    public Yellow yellow(){
        return new Yellow();
    }
    
    @Profile("test")
    @Bean("testDataSource")
    public DataSource dataSourceTest(@Value("${db.password}")String pwd) throws Exception{
        ComboPooledDataSource dataSource = new ComboPooledDataSource();
        dataSource.setUser(user);
        dataSource.setPassword(pwd);
        dataSource.setJdbcUrl("jdbc:mysql://localhost:3306/test");
        dataSource.setDriverClass(driverClass);
        return dataSource;
    }
    
    @Profile("dev")
    @Bean("devDataSource")
    public DataSource dataSourceDev(@Value("${db.password}")String pwd) throws Exception{
        ComboPooledDataSource dataSource = new ComboPooledDataSource();
        dataSource.setUser(user);
        dataSource.setPassword(pwd);
        dataSource.setJdbcUrl("jdbc:mysql://localhost:3306/ssm_crud");
        dataSource.setDriverClass(driverClass);
        return dataSource;
    }
    
    @Profile("prod")
    @Bean("prodDataSource")
    public DataSource dataSourceProd(@Value("${db.password}")String pwd) throws Exception{
        ComboPooledDataSource dataSource = new ComboPooledDataSource();
        dataSource.setUser(user);
        dataSource.setPassword(pwd);
        dataSource.setJdbcUrl("jdbc:mysql://localhost:3306/scw_0515");
        
        dataSource.setDriverClass(driverClass);
        return dataSource;
    }
​
    @Override
    public void setEmbeddedValueResolver(StringValueResolver resolver) {
        // TODO Auto-generated method stub
        this.valueResolver = resolver;
        driverClass = valueResolver.resolveStringValue("${db.driverClass}");
    }
​
}
​
​
//切换环境：
  public class IOCTest_Profile {    
    //1、使用命令行动态参数: 在虚拟机参数位置加载 -Dspring.profiles.active=test
    //2、代码的方式激活某种环境；
    @Test
    public void test01(){
        AnnotationConfigApplicationContext applicationContext = 
                new AnnotationConfigApplicationContext();//使用无参构造（之前是用有参加载配置类）
        //1、创建一个applicationContext
        //2、设置需要激活的环境
        applicationContext.getEnvironment().setActiveProfiles("dev");
        //3、注册主配置类
        applicationContext.register(MainConfigOfProfile.class);
        //4、启动刷新容器
        applicationContext.refresh();   
        
        String[] namesForType = applicationContext.getBeanNamesForType(DataSource.class);
        for (String string : namesForType) {
            System.out.println(string);
        }
        Yellow bean = applicationContext.getBean(Yellow.class);
        System.out.println(bean);
        applicationContext.close();
    }
}
​
​
@profile也可写在类上，则整个类适应某个环境

11 、AOP

业务类：即被切面的类
public class MathCalculator {   
    public int div(int i,int j){
        System.out.println("MathCalculator...div...");
        return i/j; 
    }
​
}
​
---------------------
切面类：
/**
 * 切面类
 * @Aspect： 告诉Spring当前类是一个切面类
 *
 */
@Aspect
public class LogAspects {
    //声明一个pointCut，切入点表达式由@Pointcut注释表示。切入点声明由两部分组成:一个签名包含名称和任何参数，以及一个切入点表达式，该表达式确定我们对哪个方法执行感兴趣。
    //抽取公共的切入点表达式
    //1、本类引用 
    //2、其他的切面引用
    /**
     * 申明切入点，匹配MathCalculator所有方法调用
     * execution匹配方法执行连接点
     * within:将匹配限制为特定类型中的连接点
     * args：参数
     * target：目标对象
     * this：代理对象
     */
    @Pointcut("execution(public int com.atguigu.aop.MathCalculator.*(..))")// 切入点表达式
    public void pointCut(){};// 切入点签名
    
    
    //下面是各个advice（通知）
    //@Before在目标方法之前切入；切入点表达式（指定在哪个方法切入）
    @Before("pointCut()")
    public void logStart(JoinPoint joinPoint){
        Object[] args = joinPoint.getArgs();
        System.out.println(""+joinPoint.getSignature().getName()+"运行。。。@Before:参数列表是：{"+Arrays.asList(args)+"}");
    }
    
    @After("com.atguigu.aop.LogAspects.pointCut()")  //其他切面类引用
    public void logEnd(JoinPoint joinPoint){
        System.out.println(""+joinPoint.getSignature().getName()+"结束。。。@After");
    }
    
    //JoinPoint一定要出现在参数表的第一位
    @AfterReturning(value="pointCut()",returning="result")
    public void logReturn(JoinPoint joinPoint,Object result){
        System.out.println(""+joinPoint.getSignature().getName()+"正常返回。。。@AfterReturning:运行结果：{"+result+"}");
    }
    
    @AfterThrowing(value="pointCut()",throwing="exception")
    public void logException(JoinPoint joinPoint,Exception exception){
        System.out.println(""+joinPoint.getSignature().getName()+"异常。。。异常信息：{"+exception+"}");
    }
}
​
--------------------
配置类：
/**
 * AOP：【动态代理】
 *      指在程序运行期间动态的将某段代码切入到指定方法指定位置进行运行的编程方式；
 *
 * 1、导入aop模块；Spring AOP：(spring-aspects)
 * 2、定义一个业务逻辑类（MathCalculator）；在业务逻辑运行的时候将日志进行打印（方法之前、方法运行结束、方法出现异常，xxx）
 * 3、定义一个日志切面类（LogAspects）：切面类里面的方法需要动态感知MathCalculator.div运行到哪里然后执行；
 *      通知方法：
 *          前置通知(@Before)：logStart：在目标方法(div)运行之前运行
 *          后置通知(@After)：logEnd：在目标方法(div)运行结束之后运行（无论方法正常结束还是异常结束）
 *          返回通知(@AfterReturning)：logReturn：在目标方法(div)正常返回之后运行
 *          异常通知(@AfterThrowing)：logException：在目标方法(div)出现异常以后运行
 *          环绕通知(@Around)：动态代理，手动推进目标方法运行（joinPoint.procced()）
 * 4、给切面类的目标方法标注何时何地运行（通知注解）；
 * 5、将切面类和业务逻辑类（目标方法所在类）都加入到容器中;
 * 6、必须告诉Spring哪个类是切面类(给切面类上加一个注解：@Aspect)
 * [7]、给配置类中加 @EnableAspectJAutoProxy 【开启基于注解的aop模式】
 *      在Spring中很多的 @EnableXXX;
 * 三步：
 *  1）、将业务逻辑组件和切面类都加入到容器中；告诉Spring哪个是切面类（@Aspect）
 *  2）、在切面类上的每一个通知方法上标注通知注解，告诉Spring何时何地运行（切入点表达式）
 *  3）、开启基于注解的aop模式；@EnableAspectJAutoProxy
 **/
@EnableAspectJAutoProxy   //如有配置文件也可用<aop:aspectj-autoproxy></aop:aspectj-                              autoproxy>进行基于注解版的切面功能
@Configuration
public class MainConfigOfAOP {
     
    //业务逻辑类加入容器中
    @Bean
    public MathCalculator calculator(){
        return new MathCalculator();
    }
​
    //切面类加入到容器中，也可直接在切面类@Component
    @Bean
    public LogAspects logAspects(){
        return new LogAspects();
    }
}
​

12 、AOP原理

​
------------------
AOP原理：
/**
 *  
 * AOP原理：【看给容器中注册了什么组件，这个组件什么时候工作，这个组件的功能是什么？】
 *      @EnableAspectJAutoProxy；
 * 1、@EnableAspectJAutoProxy是什么？
 *      @Import(AspectJAutoProxyRegistrar.class)：给容器中导入AspectJAutoProxyRegistrar
 *          利用AspectJAutoProxyRegistrar自定义给容器中注册bean；BeanDefinetion
 *          internalAutoProxyCreator=AnnotationAwareAspectJAutoProxyCreator
 * 
 *      给容器中注册一个AnnotationAwareAspectJAutoProxyCreator；
 * 
 * 2、 AnnotationAwareAspectJAutoProxyCreator：
 *      AnnotationAwareAspectJAutoProxyCreator
 *          ->AspectJAwareAdvisorAutoProxyCreator
 *              ->AbstractAdvisorAutoProxyCreator
 *                  ->AbstractAutoProxyCreator
 *                          implements SmartInstantiationAwareBeanPostProcessor, BeanFactoryAware
 *                      关注后置处理器（在bean初始化完成前后做事情）、自动装配BeanFactory
 * 
 * AbstractAutoProxyCreator.setBeanFactory()
 * AbstractAutoProxyCreator.有后置处理器的逻辑；
 * 
 * AbstractAdvisorAutoProxyCreator.setBeanFactory()-》initBeanFactory()
 * 
 * AnnotationAwareAspectJAutoProxyCreator.initBeanFactory()
 *
 *
 * 流程：
 *      1）、传入配置类，创建ioc容器
 *      2）、注册配置类，调用refresh（）刷新容器；
 *      3）、registerBeanPostProcessors(beanFactory);注册bean的后置处理器来方便拦截bean的创建；
 *          1）、先获取ioc容器已经定义了的需要创建对象的所有BeanPostProcessor
 *          2）、给容器中加别的BeanPostProcessor
 *          3）、优先注册实现了PriorityOrdered接口的BeanPostProcessor；
 *          4）、再给容器中注册实现了Ordered接口的BeanPostProcessor；
 *          5）、注册没实现优先级接口的BeanPostProcessor；
 *          6）、注册BeanPostProcessor，实际上就是创建BeanPostProcessor对象，保存在容器中；
 *              创建internalAutoProxyCreator的BeanPostProcessor【AnnotationAwareAspectJAutoProxyCreator】
 *              1）、创建Bean的实例
 *              2）、populateBean；给bean的各种属性赋值
 *              3）、initializeBean：初始化bean；
 *                      1）、invokeAwareMethods()：处理Aware接口的方法回调
 *                      2）、applyBeanPostProcessorsBeforeInitialization()：应用后置处理器的postProcessBeforeInitialization（）
 *                      3）、invokeInitMethods()；执行自定义的初始化方法
 *                      4）、applyBeanPostProcessorsAfterInitialization()；执行后置处理器的postProcessAfterInitialization（）；
 *              4）、BeanPostProcessor(AnnotationAwareAspectJAutoProxyCreator)创建成功；--》aspectJAdvisorsBuilder
 *          7）、把BeanPostProcessor注册到BeanFactory中；
 *              beanFactory.addBeanPostProcessor(postProcessor);
 * =======以上是创建和注册AnnotationAwareAspectJAutoProxyCreator的过程========
 * 
 *          AnnotationAwareAspectJAutoProxyCreator => InstantiationAwareBeanPostProcessor
 *      4）、finishBeanFactoryInitialization(beanFactory);完成BeanFactory初始化工作；创建剩下的单实例bean
 *          1）、遍历获取容器中所有的Bean，依次创建对象getBean(beanName);
 *              getBean->doGetBean()->getSingleton()->
 *          2）、创建bean
 *              【AnnotationAwareAspectJAutoProxyCreator在所有bean创建之前会有一个拦截，InstantiationAwareBeanPostProcessor，会调用postProcessBeforeInstantiation()】
 *              1）、先从缓存中获取当前bean，如果能获取到，说明bean是之前被创建过的，直接使用，否则再创建；
 *                  只要创建好的Bean都会被缓存起来
 *              2）、createBean（）;创建bean；
 *                  AnnotationAwareAspectJAutoProxyCreator 会在任何bean创建之前先尝试返回bean的实例
 *                  【BeanPostProcessor是在Bean对象创建完成初始化前后调用的】
 *                  【InstantiationAwareBeanPostProcessor是在创建Bean实例之前先尝试用后置处理器返回对象的】
 *                  1）、resolveBeforeInstantiation(beanName, mbdToUse);解析BeforeInstantiation
 *                      希望后置处理器在此能返回一个代理对象；如果能返回代理对象就使用，如果不能就继续
 *                      1）、后置处理器先尝试返回对象；
 *                          bean = applyBeanPostProcessorsBeforeInstantiation（）：
 *                              拿到所有后置处理器，如果是InstantiationAwareBeanPostProcessor;
 *                              就执行postProcessBeforeInstantiation
 *                          if (bean != null) {
                                bean = applyBeanPostProcessorsAfterInitialization(bean, beanName);
                            }
 * 
 *                  2）、doCreateBean(beanName, mbdToUse, args);真正的去创建一个bean实例；和3.6流程一样；
 *                  3）、
 *          
 *      
 * AnnotationAwareAspectJAutoProxyCreator【InstantiationAwareBeanPostProcessor】  的作用：
 * 1）、每一个bean创建之前，调用postProcessBeforeInstantiation()；
 *      关心MathCalculator和LogAspect的创建
 *      1）、判断当前bean是否在advisedBeans中（保存了所有需要增强bean）
 *      2）、判断当前bean是否是基础类型的Advice、Pointcut、Advisor、AopInfrastructureBean，
 *          或者是否是切面（@Aspect）
 *      3）、是否需要跳过
 *          1）、获取候选的增强器（切面里面的通知方法）【List<Advisor> candidateAdvisors】
 *              每一个封装的通知方法的增强器是 InstantiationModelAwarePointcutAdvisor；
 *              判断每一个增强器是否是 AspectJPointcutAdvisor 类型的；返回true
 *          2）、永远返回false
 * 
 * 2）、创建对象
 * postProcessAfterInitialization；
 *      return wrapIfNecessary(bean, beanName, cacheKey);//包装如果需要的情况下
 *      1）、获取当前bean的所有增强器（通知方法）  Object[]  specificInterceptors
 *          1、找到候选的所有的增强器（找哪些通知方法是需要切入当前bean方法的）
 *          2、获取到能在bean使用的增强器。
 *          3、给增强器排序
 *      2）、保存当前bean在advisedBeans中；
 *      3）、如果当前bean需要增强，创建当前bean的代理对象；
 *          1）、获取所有增强器（通知方法）
 *          2）、保存到proxyFactory
 *          3）、创建代理对象：Spring自动决定
 *              JdkDynamicAopProxy(config);jdk动态代理；
 *              ObjenesisCglibAopProxy(config);cglib的动态代理；
 *      4）、给容器中返回当前组件使用cglib增强了的代理对象；
 *      5）、以后容器中获取到的就是这个组件的代理对象，执行目标方法的时候，代理对象就会执行通知方法的流程；
 *      
 *  
 *  3）、目标方法执行   ；
 *      容器中保存了组件的代理对象（cglib增强后的对象），这个对象里面保存了详细信息（比如增强器，目标对象，xxx）；
 *      1）、CglibAopProxy.intercept();拦截目标方法的执行
 *      2）、根据ProxyFactory对象获取将要执行的目标方法拦截器链；
 *          List<Object> chain = this.advised.getInterceptorsAndDynamicInterceptionAdvice(method, targetClass);
 *          1）、List<Object> interceptorList保存所有拦截器 5
 *              一个默认的ExposeInvocationInterceptor 和 4个增强器；
 *          2）、遍历所有的增强器，将其转为Interceptor；
 *              registry.getInterceptors(advisor);
 *          3）、将增强器转为List<MethodInterceptor>；
 *              如果是MethodInterceptor，直接加入到集合中
 *              如果不是，使用AdvisorAdapter将增强器转为MethodInterceptor；
 *              转换完成返回MethodInterceptor数组；
 * 
 *      3）、如果没有拦截器链，直接执行目标方法;
 *          拦截器链（每一个通知方法又被包装为方法拦截器，利用MethodInterceptor机制）
 *      4）、如果有拦截器链，把需要执行的目标对象，目标方法，
 *          拦截器链等信息传入创建一个 CglibMethodInvocation 对象，
 *          并调用 Object retVal =  mi.proceed();
 *      5）、拦截器链的触发过程;
 *          1)、如果没有拦截器执行执行目标方法，或者拦截器的索引和拦截器数组-1大小一样（指定到了最后一个拦截器）执行目标方法；
 *          2)、链式获取每一个拦截器，拦截器执行invoke方法，每一个拦截器等待下一个拦截器执行完成返回以后再来执行；
 *              拦截器链的机制，保证通知方法与目标方法的执行顺序；
 *      
 *  总结：
 *      1）、  @EnableAspectJAutoProxy 开启AOP功能
 *      2）、 @EnableAspectJAutoProxy 会给容器中注册一个组件 AnnotationAwareAspectJAutoProxyCreator
 *      3）、AnnotationAwareAspectJAutoProxyCreator是一个后置处理器；
 *      4）、容器的创建流程：
 *          1）、registerBeanPostProcessors（）注册后置处理器；创建AnnotationAwareAspectJAutoProxyCreator对象
 *          2）、finishBeanFactoryInitialization（）初始化剩下的单实例bean
 *              1）、创建业务逻辑组件和切面组件
 *              2）、AnnotationAwareAspectJAutoProxyCreator拦截组件的创建过程
 *              3）、组件创建完之后，判断组件是否需要增强
 *                  是：切面的通知方法，包装成增强器（Advisor）;给业务逻辑组件创建一个代理对象（cglib）；
 *      5）、执行目标方法：
 *          1）、代理对象执行目标方法
 *          2）、CglibAopProxy.intercept()；
 *              1）、得到目标方法的拦截器链（增强器包装成拦截器MethodInterceptor）
 *              2）、利用拦截器的链式机制，依次进入每一个拦截器进行执行；
 *              3）、效果：
 *                  正常执行：前置通知-》目标方法-》后置通知-》返回通知
 *                  出现异常：前置通知-》目标方法-》后置通知-》异常通知
 *      
 * 
 * 
 */