关于spring:Spring

1. Spring 的 BeanFactory 和 FactoryBean 的区别

• 1. Spring 的 BeanFactory 是顶层接口，定义了 Spring 容器的基本功能，ApplicationContenxt 是 BeanFactory 的子接口，增强了 BeanFactory，减少了读取配置文件和国际化等性能

     BeanFactory
         -> ApplicationContenxt 子级接口
         -> ClassPathXmlApplicationContenxt 基于 XML 的配置
         -> FileSystemXmlApplicationContenxt 
         -> AnnotationConfigApplicationContenxt 注解配置

• 2. FactotyBean 是一种结构简单 Bean 的形式的接口，能够自定义 Bean 的细节并退出 Spring 治理

2. Bean 的生命周期

1. 初始化 Bean
2. 注入属性值
3. 如果实现 BeanNameAware 接口，调用 BeanNameAware 的setBeanName传入以后 Bean 的 ID
4. 如果实现 BeanFactoryAware 接口，调用 BeanFactoryAware 的setBeanFactory传入以后工厂实例的援用
5. 如果实现 ApplicationContextAware 接口，调用 ApplicationContextAware 的setApplicationContext传入以后 ApplicationContext 实例的援用
6. 如果有 Bean 的前置初始化处理器，调用 postProcessBeforeInitialization 执行解决
7. 如果实现 InitializingBean 接口，调用 InitializingBean 的afterPropertiesSet办法
8. 调用 init 办法进行初始化
9. 如果有 Bean 的后置初始化处理器，调用 postProcessAfterInitialization 执行解决
10. 如果作用范畴是单例，则退出 Ioc 缓存池，否则完结
11. 当 ApplicationContext 容器敞开时，调用设定的 preDestory 和destory执行销毁

/**
 * 注解将 Bean 退出 IOC
 */
@Configuration
@ComponentScan({"com.pal.entity"})
public class SpringConfig {@Bean(value = "PoDemo",initMethod = "init",destroyMethod = "destroy")
    public PoDemo getInstance(){PoDemo poDemo = new PoDemo();
        poDemo.setName("poDemo");
        return poDemo;
    }
}

/**
 * 除 process 拦截器外的生命周期办法
 */
public class PoDemo implements BeanNameAware, BeanFactoryAware, ApplicationContextAware, InitializingBean {

    private String name;
    private Integer age;

    @Override
    public void setBeanName(String name) {System.out.println("3. 注册我成为 Bean 时定义的 ID："+name);
    }

    @Override
    public void setBeanFactory(BeanFactory beanFactory) throws BeansException {System.out.println("4. 治理此 Bean 的 BeanFactory 为："+beanFactory);
    }

    @Override
    public void setApplicationContext(ApplicationContext applicationContext) throws BeansException {System.out.println("5. 治理此 Bean 的 ApplicationContext 为："+applicationContext);
    }

    @Override
    public void afterPropertiesSet() throws Exception {System.out.println("7. 属性设置之后执行 afterPropertiesSet()");
    }

    public void init() {System.out.println("8.Bean 的 Init 办法被执行");
    }
    
    @PreDestroy
    public void preDestroy() {System.out.println("10. 销毁 Bean 之前执行 preDestroy");
    }

    public void destroy() {System.out.println("11. 调用 destroy 办法销毁 Bean");
    }
  
  
    public String getName() {return name;}

    public void setName(String name) {this.name = name;}

    public Integer getAge() {return age;}

    public void setAge(Integer age) {this.age = age;}
}

/**
 * 拦挡实例化、属性注入之后的对象
 */
@Component
public class BeanPostProcessorDemo implements BeanPostProcessor {

    /**
     * Init 办法执行前的操作
     */
    @Override
    public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {if ("PoDemo".equalsIgnoreCase(beanName))
        {System.out.println("6.Init 办法前的解决！");
        }
        return null;
    }

    /**
     * Init 办法执行后的操作
     */
    @Override
    public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {if ("PoDemo".equalsIgnoreCase(beanName))
        {System.out.println("9.Init 办法后的解决！");
        }
        return null;
    }
}

/**
 * 启动办法
 */
@Test
void BeanLifeTest() {
    // 在 config 类中将 Bean 退出治理用
    AnnotationConfigApplicationContext applicationContext = new AnnotationConfigApplicationContext(SpringConfig.class);
    PoDemo poDemo = (PoDemo) applicationContext.getBean("PoDemo");
    System.out.println("加载 Bean ->"+poDemo.getName());
    applicationContext.close();}

3. Bean 加载形式

2.1 XML 形式

// 通常引入 xml 形式
ApplicationContext applicationContext = new ClassPathXmlApplicationContext("classpath:applicationContext.xml");
BeanClass bean = applicationContext.getBean("beanId");

<!-- Spring ioc 实例化 Bean 的三种形式 -->
<!-- 一：应用无参结构器（举荐）-->
<bean id = "beanId" class = "com.lagou.xxx."></bean>

<!-- 另外两种是为了将 new 的对象退出 spring 治理 -->
<!-- 二：静态方法 -->
<bean id = "beanId" class = "com.lagou.xxx.xxxFactory" factory-method = "getInstance"></bean>
public class Factory{public static XXBean getinstance(){return new XXBean();
    }
}

<!-- 三：实例化办法 -->
<bean id = "factoryBeanId" class = "com.lagou.xxx.xxxFactory"></bean>
<bean id = "beanId" factory-bean = "factoryBeanId" factory-method = "getInstance"></bean>
public class Factory{public XXBean getinstance(){return new XXBean();
    }
}

3. Bean 的作用范畴与生命周期

3.1 作用范畴

• Singleton -> 单例 bean 对象生命周期与容器雷同。
• Prototype -> 多例 bean 对象，spring 框架只负责创立，不负责销毁（JVM 回收）。
• Request,session

<bean id = "beanId" class = "com.lagou.xxx." scope = "xxx"></bean>