<bean id = "UserDao" 
name ="aaa,bbb"
class = "com.test.dao.impl.UserDaoImpl" 
scope="singleton" 
lazy-init="true"
init-method = "init"
destroy-method = "destroy"
autowire = "byType" or "byName"/> 

<constructor-arg  name="age" value="18"> </constructor-arg>
<property name = "userDao" ref = "userDao"> </property>

//注入数据结构，其余类似
<property name = "stringList">
	<list> <value> aaa </value> </list>
</property>

</bean>

//静态工厂方法
<bean id = "UserDao1" 
class = "com.test.factory.MyBeanFactory1"
factory-method = "UserDao">
</bean>

//实例工厂方法
<bean id ="MybeanFactory2" 
class = "com.test.factory.MyBeanFactory2"
</bean>

<bean id = "UserDao2" 
factory-bean = "MybeanFactory2">
factory-method = "UserDao">
</bean>

//Factorybeany延迟调用
<bean id ="MybeanFactory3" 
class = "com.test.factory.MyBeanFactory2"
</bean>

public class MybeanFactory3 implements FactoryBean<UserDao>{
	
	@override
	public UserDao getObject() throws Expection{
		return new UserDaoImpl();
	}
	
	@override
	public class<?> getObejectType(){
		return UserDao.class;
	}
}

Object getBean(String beanName) 
//需要强制转换
UserService userService = (UserService)applicationContext.getBean("	userService")

T getBean(Class type)
T getBean(String beanName,Class type)

//github上 min-spring的实现过程，此时未使用applicationContext 
//接口
public interface BeanFactoryPostProcessor {  
    void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) throws BeansException;
    
//实现
public class CustomBeanFactoryPostProcessor implements BeanFactoryPostProcessor {  
  
    @Override  
    public void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) throws BeansException {  
       System.out.println("CustomBeanFactoryPostProcessor#postProcessBeanFactory");  
       BeanDefinition personBeanDefiniton = beanFactory.getBeanDefinition("person");  
       PropertyValues propertyValues = personBeanDefiniton.getPropertyValues();  
       //将person的name属性改为ivy  
       propertyValues.addPropertyValue(new PropertyValue("name", "ivy"));  
    }  
}

//测试
public class BeanFactoryProcessorAndBeanPostProcessorTest {
	public void testBeanFactoryPostProcessor() throws Exception {
		DefaultListableBeanFactory beanFactory = new DefaultListableBeanFactory();
		XmlBeanDefinitionReader beanDefinitionReader = new XmlBeanDefinitionReader(beanFactory);
		beanDefinitionReader.loadBeanDefinitions("classpath:spring.xml");

		//在所有BeanDefintion加载完成后，但在bean实例化之前，修改BeanDefinition的属性值
		CustomBeanFactoryPostProcessor beanFactoryPostProcessor = new CustomBeanFactoryPostProcessor();
		beanFactoryPostProcessor.postProcessBeanFactory(beanFactory);

		Person person = (Person) beanFactory.getBean("person");
		System.out.println(person);
		//name属性在CustomBeanFactoryPostProcessor中被修改为ivy
		assertThat(person.getName()).isEqualTo("ivy");
	}

// 注解的作用 类似代替原有的
<bean id = "UserDao" 
name ="aaa,bbb"
class = "com.itheima.dao.impl.UserDaoImpl" ></bean>
 

@Target(ElementType.TYPE)
@Retention(Retention.RUNTIME)
public @interface Mycomponent{
  string value;
}

@Mycomponent("otherbena")
public class UserDaoImpl implements UserDao{
}

public class MyComponentBeanFactoryPostProcessor implements BeanDefinitionRegistryPostProcessor {
    @Override
    public void postProcessBeanDefinitionRegistry(BeanDefinitionRegistry registry) throws BeansException {
       //通过扫描工具扫描指定包以及子包下的所有类，收集使用@Mycomponent注解的类
       My<string,class> myComponentAnnotationMap  = BaseClassScanUtils.scanMyComponentAnnotation("com.test")
       myComponentAnnotationMap.foreach((beanName,clazz))->(string beanClassName = clazz.getname);
    BeanDefinition beanDefinition = new RootBeanDefinition();
    beanDefinition.setBeanClassName("beanClassName");
    registry.registerBeanDefinition(beanName, beanDefinition);  
    }
//xml中配置MyComponentBeanFactoryPostProcessor让他生效

    @Override
public void postProcessBeanFactory(ConfigurableListableBeanFactory ){
}
}

//xml中配置MyBeanPostProcessor 不使用注解的流程
public class MyBeanPostProcessor implements BeanPostProcessor {
    @Override
    public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
        System.out.println("beanPostProcessor的before()执行了...." + beanName);
        return bean;
    }

    @Override
    public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
        System.out.println("beanPostProcessor的after()执行了...."+ beanName);
        return bean;
    }
}



public class Boo {
    private Long id;
    private String name;

    public Boo() {
        System.out.println("boo实例化构造方法执行了...");
    }

    @PostConstruct
    // 该注解表示实例化之后执行该初始化方法
    public void init() {
        System.out.println("boo执行初始化init()方法了...");
    }
}


public class MyConfig {

   
    public static void main(String[] args) {
        AnnotationConfigApplicationContext applicationContext = new AnnotationConfigApplicationContext(MyConfig.class);
      
}
//需要配置xml文件，结果如下
/**
boo实例化构造方法执行了... 
beanPostProcessor的before()执行了....
boo boo执行初始化init()方法了... 
beanPostProcessor的after()执行了....boo
**/

//使用注解时xml文件中还必须有配置，让spring扫描注解来获得bean对象
<context:component-scan base-package ="com.test"/>
@Scope("singleton")
@Component("userService")
@Lazy(true)
public class UserServiceImpl implements UserService{
@PostConstruct
...
@PreDestory
...
}

<?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 https://www.springframework.org/schema/beans/spring-beans.xsd"> </beans>


@Configuration
@ComponentScan("com.test")
@PropertySource("...") 
@Import("OtherBean.classs")//导入外部配置类
public class MainConfiguration {
 }

<?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:aop="http://www.springframework.org/schema/aop"
//配置AOP命名空间 
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"> </beans>

public class example { 
public void test(){
 System.out.println("测试"); 
} 
}

<bean class="com.example"/>

public class exampleAOP { 
public void aftertest() { 
System.out.println("测试之后"); 
} 
}


<aop:config>
<aop:pointcut id="test" expression=""execution(* org.example.example.test())"/>
//相当 expression=""execution(public void com.example.test())
<aop:aspect ref="exampleAOP"> 
<aop:after method="aftertest" pointcut-ref="test"/> 
</aop:aspect>
</aop:config>