public class InsFactory {
	public static Car getCar(String buyer){
		System.out.println("静态方法被调用...");		
		Car car = new Car();
		car.setBuyer(buyer);
		car.setBrand("宝马");
		car.setPrice(400000.0);
		return car;
	}
}

public class StaFactory {	
	public Car getCar(String buyer){
		System.out.println("实例方法被调用...");
		Car car = new Car();
		car.setBuyer(buyer);
		car.setBrand("奔驰");
		car.setPrice(300000.0);
		return car;
	}
}

/**
 * 实现了FactoryBean的接口的类是Spring认可的工厂类
 * Spring会自动地调用工厂方法创建实例
 * @author 腾飞
 *
 */
public class MyFactory implements FactoryBean<Car>{

	/**
	 * getObject()工厂方法：返回创建的对象
	 */
	@Override
	public Car getObject() throws Exception {
		// TODO Auto-generated method stub
		System.out.println("FactoryBean创建对象...");
		Car car = new Car();
		car.setBrand("奥迪");
		car.setPrice(200000.00);
		return car;
	}
	
	/**
	 * 返回创建的对象类型
	 * Spring会自动调用这个方法来确认创建对象是什么类型
	 */
	@Override
	public Class<?> getObjectType() {
		// TODO Auto-generated method stub
		return null;
	}

	/**
	 * isSingleton:是单例吗？
	 * 	false:多例
	 * 	true:单例
	 */
	@Override
	public boolean isSingleton() {
		// TODO Auto-generated method stub
		return false;
	}

}

public static void main(String[] args) {
	ApplicationContext ac = new ClassPathXmlApplicationContext("factory-bean.xml");

	System.out.println("----静态工厂----");
	Object car01 = ac.getBean("car01");
	System.out.println(car01);

	System.out.println("----实例工厂----");
	Object car02 = ac.getBean("car02");
	System.out.println(car02);
	
	System.out.println("----FactoryBean----");
	Object bean = ac.getBean("factory");
	System.out.println(bean);

}

System.out.println("容器启动完成...");
Student stu1 = ac.getBean("student1", Student.class);
Student stu2 = ac.getBean("student1", Student.class);
System.out.println(stu1==stu2);

public class MyBeanPostProcessor implements BeanPostProcessor {

	/**
	 * postProcessBeforeInitialization:初始化之前调用
	 */
	@Override
	public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
		// TODO Auto-generated method stub
		System.out.println("["+beanName+"]bean将要调用初始化方法了,这个bean是["+bean+"]");
		return bean;
	}
	
	/**
	 * postProcessAfterInitialization:初始化之后调用
	 */
	@Override
	public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
		// TODO Auto-generated method stub
		System.out.println("["+beanName+"]bean的初始化方法调完了,这个bean是["+bean+"]");
		return bean;
	}

}

/**
 * bean的生命周期:
 * 	单例的:构造器-->初始化方法-->(容器关闭)销毁方法
 * 	多例的:获取bean(构造器-->初始化方法)-->容器关闭,但不会调用bean的销毁方法
 * 	后置处理器:(容器启动)构造器--[后置处理器before]->初始化方法--[后置处理器after]->bean初始化完成
 * 无论bean是否有初始化方法，后置处理器都会默认其有，还会工作
 */
ConfigurableApplicationContext cac = new ClassPathXmlApplicationContext("applicationContext.xml");
System.out.println("容器打开!");
Student stu3 = cac.getBean("student2", Student.class);
System.out.println("对象"+stu3);
System.out.println("容器关闭!");
cac.close();

@Repository
/**
 * id默认是类名首字母小写
 * @author 腾飞
 *
 */
public class BookDao {

}

ApplicationContext ac = new ClassPathXmlApplicationContext("applicationContext.xml");
	public static void main(String[] args) {	
		/**
		 * 使用注解加入到容器中的组件，和使用配置加入到容器中的组件行为默认都是一样的
		 * 1.组件的id：默认就是组建的类名首字母小写(bookDao)
		 * 		重命名:@Repository("book")
		 * 2.组件的作用域：默认就是单例的
		 * 		多实例:@Scope(value="prototype")
		 */
		Object bean1 = ac.getBean("book");
		Object bean2 = ac.getBean("book");
		System.out.println(bean1==bean2);
	}

//@Autowired:自动装配，自动为这个属性赋值。
@Autowired(required=false)
private BookService bookService;
public void doGet(){
	bookService.seve();
}

//@Qualifier:指定一个名为id进行查找。
@Qualifier("bookServices")
@Autowired(required=false)
private BookService bookServices;
public void doGet(){
	bookService.seve();
}

@Controller
public class BookServlet {
	//@Qualifier:指定一个名为id进行查找。
	@Qualifier("bookService")
	@Autowired(required=false)
	private BookService bookService;
	public void doGet(){
		bookService.seve();
	}
	/**
	 * 方法上@Autowired
	 * 	1.方法上的每一个参数都会自动注入值
	 * @param bookDao
	 */
	@Autowired
	public void getDao(BookDao bookDao,BookService bookService){
		System.out.println("Spring运行了这个方法..."+bookDao+"  ,bookService"+bookService);
		
	}
	
    
@Service
public class BookService {
	@Autowired
	private BookDao bookDao;
	public void seve(){
		System.out.println("bookService正在调用Dao帮你保存图书...");
		bookDao.saveBook();
	}

    
@Repository
@Scope(value="prototype")
/**
 * id默认是类名首字母小写
 * @author 腾飞
 *
 */
public class BookDao {
	public void saveBook(){
		System.out.println("成功保存图书！");
	}
    
    
public class Test {
	public static void main(String[] args) {
		ApplicationContext ac = new ClassPathXmlApplicationContext("applicationContext.xml");
		
		System.out.println("---------@Autowired自动装配----------");
		BookServlet bookservlet = ac.getBean(BookServlet.class);
		bookservlet.doGet();
	}

@Service
public class BookService {
    //查找名为bookDao的类
	@Resource(name="bookDao")
	private BookDao bookDao;
	public void seve(){
		System.out.println("bookService正在调用Dao帮你保存图书...");
		bookDao.saveBook();
	}

/**
 * Spring的单元测试
 * 1.导入Spring的单元测试包
 * 2.@ContextConfiguration(locations="")使用它来指定Spring的配置文件的位置
 * 3.@RunWith()指定用那种驱动进行单元测试，默认为junit
 */
@ContextConfiguration(locations="classpath:applicationContext.xml")
//使用Spring的单元测试模块执行标了@Test的测试方法
@RunWith(SpringJUnit4ClassRunner.class)
public class Test {
	ApplicationContext act = null;
	
	@Autowired
	BookServlet bookServlet;
	@Autowired
	BookDao bookDao;

	@org.junit.Test
	public void test1(){
		System.out.println("---------单元测试----------");
		System.out.println(bookServlet);
		System.out.println(bookDao);
	}
}

	public static void main(String[] args) {
		ApplicationContext ioc = new ClassPathXmlApplicationContext("applicationContext.xml");
		BookService book = ioc.getBean(BookService.class);
		UserService user = ioc.getBean(UserService.class);		
		book.save();
		user.save();
		//getGenericSuperclass()：带泛型的父类
		//Spring中可以使用带泛型的父类确定这个子类的类型
		System.out.println("父类"+book.getClass().getGenericSuperclass());
		
//		ioc是一个容器，帮我们管理所有的组件
//		1.依赖注入；@Autowired；自动赋值
//		2.某个组件要使用Spring提供的更多（IOC、AOP）必须加入到容器中。
//		过程
//		1.容器启动，创建单实例的bean。
//		2.autowired自动装配的时候，是从容器中找到这些符合要求的bean。
//		3.`ioc.getBean();`也是从容器中找到这个bean。
//		4.容器中包含了所有的bean。
//		5.调试Spring的源码，容器就是一个map。
//		6.这个map中保存所有创建好的bean，并提供外界获取功能。
		
	}