spring学习笔记1

构造器注入

<bean id="bean1" class="x.x.x">
<constructor-arg ref="bean2"/>
</bean>

<bean id="bean2" class="x.x.y">
<constructor-arg value="#{T{System}.out}"/>
</bean>

{T{System}.out}属于spring表达式语言。

工厂方法注入

public class CarFactory {
    public Car createCar(){
        Car car = new Car();
        car.setBrand("丰田");
        return car;
    }
}

  <bean id="carFactory" class="x.x.CarFactory"/>
    <bean id="car2" factory-bean="carFactory" factory-method="createCar"/>

如果是静态工厂，即createCar方法是静态的，则不用指定factory-bean属性。

java配置

@Configuration
public class CDPlayerConfig {

  @Bean(name="xxxx")
  public CompactDisc compactDisc() {
    return new SgtPeppers();
  }
  //没有name属性的话bean的id默认为方法的名字
  @Bean
  public CDPlayer cdPlayer(CompactDisc compactDisc) {
    return new CDPlayer(compactDisc);
  }
}

spring应用上下文

Spring应用上下文全权负责对象的创建和组装。Spring
自带了多种应用上下文的实现，它们之间主要的区别仅仅在于如何加
载配置。例如ClassPathXmlApplicationContext。

切面简介

AOP经常用在日志，事务和安全模块。
好处：AOP能够使这些服务模块化，并以声明的方式将它们应用到它们需要
影响的组件中去。所造成的结果就是这些组件会具有更高的内聚性并
且会更加关注自身的业务。你的核心应用甚至根本不知道它们的存在，可以将安全、事务和日志关注点与核心业务逻辑相分
离。

个人简单理解

切面就是业务程序被服务切入形成的面，可以把它看成一个整体。切面包含切点和通知。切点就是要服务要注入的点。通知就是服务类里的具体方法，他需要引用切点。即在一个切面执行什么样的动作就是一个通知。

<aop:config>
        <aop:aspect ref="audience">
            <aop:pointcut expression="execution(** concert.Performance.perform(..))" id="performance"/>
            <aop:before method="silenceCellPhones"
            pointcut-ref="performance"/>
            <aop:after-returning method="applause"
            pointcut="execution(** concert.Performance.perform(..))"/>
            <aop:after-throwing method="demandfund"
            pointcut="execution(** concert.Performance.perform(..))"/>
        </aop:aspect>
    </aop:config>

spring容器

Spring容器并不是只有一个。Spring自带了多个容器实现，可以归为
两种不同的类型。
1. bean工厂:（由org.springframework. beans.
factory.BeanFactory接口定义）是最简单的容器，提供基本的DI
支持。
2. 应用 上下文：（由org.springframework.context.ApplicationContext
接口定义）基于BeanFactory构建，并提供应用框架级别的服务，例如
从属性文件解析文本信息以及发布应用事件给感兴趣的事件监听者。

应用上下文

Spring自带了多种类型的应用上下文。

• AnnotationConfigApplicationContext：从一个或多个
  基于Java的配置类中加载Spring应用上下文。
• AnnotationConfigWebApplicationContext：从一个或
  多个基于Java的配置类中加载Spring Web应用上下文。
• ClassPathXmlApplicationContext：从类路径下的一个或
  多个XML配置文件中加载上下文定义，把应用上下文的定义文件
  作为类资源。
• FileSystemXmlapplicationcontext：从文件系统下的一
  个或多个XML配置文件中加载上下文定义。
• XmlWebApplicationContext：从Web应用下的一个或多个
  XML配置文件中加载上下文定义。

spring bean生命周期

1. 实例化
2. 填充属性
3. 调用BeanNameAware的setBeanName()方法
4. 调用BeanFactoryAware的setBeanFactory()方法
5. 调用ApplicationContextAware的setApplicationContext()方法
6. 调用BeanPostProcessor的预初始化方法(postProcessBeforeInitialization)
7. 调用InitializingBean的afterProperitesSet()方法.如果没有实现接口，但是使用init-method声明了初始化方法，该方法也会被调用。
8. 调用自定义的初始化方法
9. 调用BeanPostProcessor的初始化后方法(postProcessAfterInitailization)。
10. bean可以使用了
11. 调用DisposableBean的destroy()方法。如果bean使用了destroy-method声明了销毁方法，该方法也会被调用。
12. 调用自定义的销毁方法。

@Component
public class TestBean implements BeanNameAware,BeanFactoryAware,ApplicationContextAware
                    ,BeanPostProcessor,InitializingBean,DisposableBean{

    public TestBean(){
        System.out.println("实例化");
    }

    @Override
    public void setBeanName(String name) {
        System.out.println("my bean name is:"+name);
    }

    @Override
    public void setBeanFactory(BeanFactory beanFactory) throws BeansException {
        System.out.println("bean factory:"+beanFactory.containsBean("userService"));
    }

    @Override
    public void setApplicationContext(ApplicationContext applicationContext) throws BeansException {
        System.out.println("applicationcontext:"+applicationContext.getApplicationName());
    }

    @Override
    public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
        System.out.println("BeanPostProcessor.postProcessBeforeInitialization execute:");
        return bean;
    }

    @Override
    public void afterPropertiesSet() throws Exception {
        System.out.println("InitializingBean.afterPropertiesSet execute!");
    }


    @Override
    public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
        System.out.println("BeanPostProcessor.postProcessAfterInitialization execute:");
        return bean;
    }

    @Override
    public void destroy() throws Exception {
        System.out.println("DisposableBean.destroy execute!");
    }