package com.wq.createobject;
public class HelloWorld {
	public void sayHello(){
		System.out.println("Hello wuqingvika");
	}
}

package com.xzit.test;
import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
import com.wq.createobject.HelloWorld;
import junit.framework.TestCase;
public class HelloWorldTest extends TestCase {
	@Test
	public void testHelloWorld(){
		
		ApplicationContext context=new 
			ClassPathXmlApplicationContext("applicationContext.xml");
		HelloWorld wq=(HelloWorld)context.getBean("HelloWorld");
		wq.sayHello();
	}
}

/**
	 * 在spring容器中，默认情况下调用了一个类的默认的构造函数创建对象
	 */
    	 
    public class HelloWorld {
    	public HelloWorld(){
    		System.out.println("hello wucan");
    	}
    	public void sayHello(){
    		System.out.println("Hello wuqingvika");
    	}
    }

@Test
	public void testHelloWorld_Default(){
		ApplicationContext context=new 
			ClassPathXmlApplicationContext("applicationContext.xml");
		//根据id把spring容器中的bean提取出来了
		HelloWorld wq=(HelloWorld)context.getBean("HelloWorld");
		wq.sayHello();
	}

package com.wq.createobject.method.factory;
import com.wq.createobject.method.HelloWorld;
public class HelloWorldFactory {
	public static HelloWorld getInstance(){
		return new HelloWorld();
	}
}

/**
	 * 利用静态工厂模式创建对象
	 * <bean id="helloWorld2" 
		class="com.itheima12.spring.createobject.method.factory.HelloWorldFactory"
		factory-method="getInstance"></bean>
		  spring容器内部调用了HelloWorldFactory中的getInstance方法创建对象
		      而具体的new对象的过程是由程序员来完成的。
	 */
	@Test
	public void testHelloWorldFactory(){
		
		ApplicationContext context=new 
			ClassPathXmlApplicationContext("applicationContext.xml");
		HelloWorld wq=(HelloWorld)context.getBean("helloWorld2");
		wq.sayHello();
	}

package com.wq.createobject.method.factory;
import com.wq.createobject.method.HelloWorld;
public class HelloWorldFactory2 {
	public  HelloWorld getInstance(){
		return new HelloWorld();
	}
}

/**
	 * 实例工厂方法
	 */
	@Test
	public void testCreateObject_InstaceFactory(){
		//启动spring容器
		ApplicationContext context = 
				new ClassPathXmlApplicationContext("applicationContext.xml");
		HelloWorld helloWorld = (HelloWorld)context.getBean("helloWorld3");
		helloWorld.sayHello();
	}

package com.wq.alias;
public class HelloWorld {
	public void sayHello(){
		System.out.println("Hello wuqingvika");
	}
}

public void testHelloWorld(){
		//启动spring容器
		ApplicationContext context=new 
			ClassPathXmlApplicationContext("applicationContext.xml");
		HelloWorld wq=(HelloWorld)context.getBean("HelloWorld");
		wq.sayHello();
		HelloWorld wq1=(HelloWorld)context.getBean("吴大大");
		wq1.sayHello();
		HelloWorld wq2=(HelloWorld)context.getBean("吴小小");
		wq2.sayHello();
	}

<bean id="helloWorld" 
    	class="com.itheima12.spring.createobject.when.HelloWorld"></bean>
    <bean id="helloWorld2" 
    	class="com.itheima12.spring.createobject.when.HelloWorld" lazy-init="true"></bean>

    /**
    	 * 在默认的情况下，启动spring容器的时候创建对象
    	 *    因为是在spring容器启动的时候就创建对象，所以只要配置文件书写错误，在一开始的时候(web容器启动)就能发现错误了
    	 */
    	@Test
    	public void testHelloWorld_Default(){
    		ApplicationContext context = 
    				new ClassPathXmlApplicationContext("applicationContext.xml");
    		HelloWorld helloWorld = (HelloWorld)context.getBean("helloWorld");
    		helloWorld.hello();
    	}
    	
    	/*
    	 * <bean id="helloWorld2" 
    		class="com.itheima12.spring.createobject.when.HelloWorld" 
    		lazy-init="true"></bean>
    		在context.getBean时才要创建该对象
    	 */
    	@Test
    	public void testHelloWorld_Lazy_init_TRUE(){
    		ApplicationContext context = 
    				new ClassPathXmlApplicationContext("applicationContext.xml");
    		HelloWorld helloWorld = (HelloWorld)context.getBean("helloWorld");
    		HelloWorld helloWorld2 = (HelloWorld)context.getBean("helloWorld2");
    		helloWorld.hello();
    	}

<bean id="HelloWorld" class="com.wq.scope.HelloWorld"></bean>`

     * 在spring容器中的对象，默认情况下是单例的
    	 *    因为对象是单例的，所以只要在类上声明一个属性，该属性中含有数据，
    	 *    那么该属性是全局的（很危险）
    	 *============(输出结果）=============
    	 * 这是无参构造方法哟
    	 *	com.wq.scope.HelloWorld@7cdbc5d3
    	 *	com.wq.scope.HelloWorld@7cdbc5d3
    	 *====================================
    	 */
    	@Test
    	public void testHelloWorld_default(){
    		//启动spring容器
    		ApplicationContext context=new 
    			ClassPathXmlApplicationContext("applicationContext.xml");
    		HelloWorld wq=(HelloWorld)context.getBean("HelloWorld");
    		HelloWorld wq1=(HelloWorld)context.getBean("HelloWorld");
    		System.out.println(wq);
    		System.out.println(wq1);
    	}

/**
	 * 如果说scope为"prototype"的时候，spring容器产生的对象就是多实例
	 *    无论lazy-init为什么值，都是在context.getBean时才要创建对象
	 *============(输出结果）=============
	 * 这是无参构造方法哟
     * 这是无参构造方法哟
     * com.wq.scope.HelloWorld@2b80d80f
     * com.wq.scope.HelloWorld@3ab39c39
	 *====================================
	 */
	@Test
	public void testHelloWorld_scope_prototype(){
		//启动spring容器
		ApplicationContext context=new 
			ClassPathXmlApplicationContext("applicationContext.xml");
		HelloWorld wq=(HelloWorld)context.getBean("HelloWorld2");
		HelloWorld wq1=(HelloWorld)context.getBean("HelloWorld2");
		System.out.println(wq);
		System.out.println(wq1);
	}

/**
	 * 
	 * 在构造函数之后，立刻执行init方法
	 * 如果spring容器没有执行close方法，则不执行销毁方法
	 * 如果spring容器执行了close方法，在执行该方法之前要执行销毁方法
	 */
@Test
public void testHelloWorld_default(){
	//启动spring容器
	ApplicationContext context=new 
		ClassPathXmlApplicationContext("applicationContext.xml");
	HelloWorld wq=(HelloWorld)context.getBean("HelloWorld");
	wq.sayHello();
	ClassPathXmlApplicationContext contextwq=(ClassPathXmlApplicationContext)context;
	contextwq.close();
}

package com.wq.di.xml.setter;
public class Student {
	public void say(){
		System.out.println("Student...");
	}
}

package com.wq.di.xml.setter;

import java.util.List;
import java.util.Map;
import java.util.Properties;
import java.util.Set;

public class Person {
	private Long pid;
	private String pname;
	private Student student;
	private List lists;
	private Set sets;
	private Map maps;
    private Properties properties;
	public Properties getProperties() {
		return properties;
	}
	public void setProperties(Properties properties) {
		this.properties = properties;
	}
	private Object[] objects;
	public Long getPid() {
		return pid;
	}
	public void setPid(Long pid) {
		this.pid = pid;
	}
	public String getPname() {
		return pname;
	}
	public void setPname(String pname) {
		this.pname = pname;
	}
	public Student getStudent() {
		return student;
	}
	public void setStudent(Student student) {
		this.student = student;
	}
	public List getLists() {
		return lists;
	}
	public void setLists(List lists) {
		this.lists = lists;
	}
	public Set getSets() {
		return sets;
	}
	public void setSets(Set sets) {
		this.sets = sets;
	}
	public Map getMaps() {
		return maps;
	}
	public void setMaps(Map maps) {
		this.maps = maps;
	}
	public Object[] getObjects() {
		return objects;
	}
	public void setObjects(Object[] objects) {
		this.objects = objects;
	}
}

@Test
public void testHelloWorld_di_xml_setter(){
	//启动spring容器
	ApplicationContext context=new 
		ClassPathXmlApplicationContext("applicationContext.xml");
	Person p=(Person)context.getBean("person");
	System.out.println(p.getPname()+"  "+p.getLists().size());
}

public interface Document {
	public void writeDocument();
	public void readDocument();
}

public class ExcelDocument implements Document {

	@Override
	public void writeDocument() {
		// TODO Auto-generated method stub
		System.out.println("Excel Write");
	}

	@Override
	public void readDocument() {
		// TODO Auto-generated method stub
		System.out.println("Excel read");
	}

}

public class DocumentManager {
	private Document document;//定义一个接口
	public DocumentManager(Document document){
		this.document=document;
	}
	public void readDocument(){
		this.document.readDocument();
	}
	
	public void writeDocument(){
		this.document.writeDocument();
	}
}

public class DocumentTest{
	@Test
	public void testDocument_NoSpring(){
		Document document=new WordDocument();
		DocumentManager dm=new DocumentManager(document);
		dm.readDocument();
		dm.writeDocument();
	}
}

public class DocumentManager {
	private Document document;
//	public DocumentManager(Document document){
//		this.document=document;
//	}
	
	public void readDocument(){
		this.document.readDocument();
	}
	
	public Document getDocument() {
		return document;
	}

	public void setDocument(Document document) {
		this.document = document;
	}

	public void writeDocument(){
		this.document.writeDocument();
	}
}

public interface PersonDao {
	public void savePerson();
}

public class PersonDaoImpl implements PersonDao {

	@Override
	public void savePerson() {
		// TODO Auto-generated method stub
		System.out.println("save person hahahaha...");
	}
}

public interface PersonService {
	public void savePerson();
}

public class PersonServiceImpl implements PersonService {
	private PersonDao personDao;
	
	public PersonDao getPersonDao() {
		return personDao;
	}
	public void setPersonDao(PersonDao personDao) {
		this.personDao = personDao;
	}
	@Override
	public void savePerson() {
		// TODO Auto-generated method stub
		this.personDao.savePerson();
	}
}

public class PersonAciton {
	private PersonService personService;

	public PersonService getPersonService() {
		return personService;
	}

	public void setPersonService(PersonService personService) {
		this.personService = personService;
	}
	public void savePerson(){
		this.personService.savePerson();
	}
}

public class MVCTest {

	@Test
	public void testMvc(){
		ApplicationContext context=
			new ClassPathXmlApplicationContext("applicationContext.xml");
		PersonAciton personAction=(PersonAciton)context.getBean("personAction");
		personAction.savePerson();
	}
}

public class Student {
	public void say(){
		System.out.println("Student...");
	}
}

@Test
	public void testHelloWorld_di_xml_constructor(){
		//启动spring容器
		ApplicationContext context=new 
			ClassPathXmlApplicationContext("applicationContext.xml");
		Person p=(Person)context.getBean("person");
		System.out.println(p.getPname());
		p.getStudent().say();
	}

public class Person {
	private String name;

	public String getName() {
		return name;
	}

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

public class Student extends Person {

}

@Test
	public void testExtends(){
		ApplicationContext context=
			new ClassPathXmlApplicationContext("applicationContext.xml");
		//Student st=(Student) context.getBean("student");
		Student st=(Student) context.getBean("student2");
		System.out.println(st.getName());
	}

import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;
/**
 * 注解类
 * @author wuqingvika
 *
 */
@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
public @interface ClassInfo {
	String name() default "";
}

import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
public @interface MethodInfo {
	String name() default "";
}

@ClassInfo(name="这就是传说中的07Wu")
public class Wuqingvika07Wu {
	@MethodInfo(name="传说中的Java学科")
   public void Java(){
   }
}

import java.lang.reflect.Method;
import org.junit.Test;

public class AnnotationParse {
//注解解析
	public static void parse(){
	  Class class1=	Wuqingvika07Wu.class;
	  //该类上面是否存在ClassInfo的注解
	  if(class1.isAnnotationPresent(ClassInfo.class)){
		  //获取类上面的classInfo注解
		  ClassInfo classInfo=(ClassInfo) 
		  		class1.getAnnotation(ClassInfo.class);
		  System.out.println(classInfo.name());
		  
	  }
	  Method[] methods=  class1.getMethods();
	  for (Method method : methods) {
		//判断该方法上面是否存在MethodInfo的注解
		if(method.isAnnotationPresent(MethodInfo.class)){
			//获取到方法上面的注解
			MethodInfo methodInfo=method.getAnnotation(MethodInfo.class);
			System.out.println(methodInfo.name());
		}
	  }
	}
	
	@Test
	public void testAnnotation(){
		AnnotationParse.parse();
	}
}

public class Student {
	public void say(){
		System.out.println("Student...");
	}
}

import javax.annotation.Resource;

public class Person {
//	@Resource
	@Resource(name="student")
//	@Autowired  //按照类型进行匹配
//	@Qualifier("student")//按照id匹配，这两项等价于@Resource(name="student")
	private Student student;

	public Student getStudent() {
		return student;
	}

	public void setStudent(Student student) {
		this.student = student;
	}
}

/**
 * 原理
 *    1、当启动spring容器的时候，创建两个对象
 *    2、当spring容器解析到
 *    		 <context:annotation-config></context:annotation-config>
 *        spring容器会在spring容器管理的bean的范围内查找这些类的属性上面是否加了@Resource注解
 *    3、spring解析@Resource注解的name属性
 *    		如果name属性为""
 *              说明该注解根本没有写name属性
 *              spring容器会得到该注解所在的属性的名称和spring容器中的id做匹配，如果匹配成功，则赋值
 *                                                               如果匹配不成功,则按照类型进行匹配
 *          如果name属性的值不为""
 *               则按照name属性的值和spring的id做匹配，如果匹配成功，则赋值，不成功，则报错
 *   说明:
 *       注解只能用于引用类型
 *       注解写法比较简单,但是效率比较低
 *       xml写法比较复杂，但是效率比较高
 * @author wuqingvika
 *
 */

    public class AnnotationTest extends TestCase {
    	
    	@Test
    	public void testHelloWorld_di_annotation(){
    		//启动spring容器
    		ApplicationContext context=new 
    			ClassPathXmlApplicationContext("applicationContext.xml");
    		Person p=(Person)context.getBean("person");
    		p.getStudent().say();
    		
    	}
    }

import org.springframework.stereotype.Component;
@Component("student")
public class Student {
	public void say(){
		System.out.println("Student...");
	}
}

@Component("person")
public class Person {
	@Resource(name="student")
	private Student student;

	public Student getStudent() {
		return student;
	}

	public void setStudent(Student student) {
		this.student = student;
	}
	
}

public class ScanTest extends TestCase {
	
	@Test
	public void testHelloWorld_di_scan(){
		//启动spring容器
		ApplicationContext context=new 
			ClassPathXmlApplicationContext("applicationContext.xml");
		Person p=(Person)context.getBean("person");
		p.getStudent().say();
		
	}
}

@Component("documentManager")
public class DocumentManager {
	@Resource(name="wordDocument")//这里赋值为wordDocument哦。
	private Document document;
	
	public void readDocument(){
		this.document.readDocument();
	}

	public void writeDocument(){
		this.document.writeDocument();
	}
}

@Component("wordDocument")
public class WordDocument implements Document {
	@Override
	public void writeDocument() {
		// TODO Auto-generated method stub
		System.out.println("Word Write");
	}

	@Override
	public void readDocument() {
		// TODO Auto-generated method stub
		System.out.println("Word read");
	}
}

    <context:component-scan base-package="com.wq.spring.iocdi"></context:component-scan>
``` 

>注意:base-package为要扫描的类的包名。

15.4测试方法
--------
```java
    @Test
    	public void testDocument_Spring(){
    		ApplicationContext context=
    			new ClassPathXmlApplicationContext("applicationContext.xml");
    		DocumentManager dm=(DocumentManager) context.getBean("documentManager");
    		dm.writeDocument();
    		dm.readDocument();
    	}

package com.wq.spring.dao;

public interface PersonDao {
	public void savePerson();
}

//存储层
@Repository("personDao")
public class PersonDaoImpl implements PersonDao {

	@Override
	public void savePerson() {
		// TODO Auto-generated method stub
		System.out.println("save person wqhahahaha...");
	}
}

package com.wq.spring.service;

public interface PersonService {
	public void savePerson();
}

//业务层
@Service("personService")
public class PersonServiceImpl implements PersonService {
	@Resource
	private PersonDao personDao;
	
	public PersonDao getPersonDao() {
		return personDao;
	}

	public void setPersonDao(PersonDao personDao) {
		this.personDao = personDao;
	}

	@Override
	public void savePerson() {
		// TODO Auto-generated method stub
		this.personDao.savePerson();
	}

}

//展示层
@Controller("personAction")
@Scope("prototype")
public class PersonAciton {
	@Resource(name="personService")
	private PersonService personService;

	public void savePerson(){
		this.personService.savePerson();
	}
}

public class MVCTest {

	@Test
	public void testMvc(){
		ApplicationContext context=
			new ClassPathXmlApplicationContext("applicationContext.xml");
		PersonAciton personAction=(PersonAciton)context.getBean("personAction");
		personAction.savePerson();
	}
}