//剧本
public class MoAttack {
	private BEN ben;

	public MoAttack(BEN ben) {
		this.ben = ben;		
	}   //通过构造函数注入BEN的具体饰演者
	
	public void cityGateAsk() {
		ben.responseAsk("墨者革离");
	}
}
//剧本不关心是谁饰演BEN这个角色，只需要传入演员让其完成具体动作即可
//导演
public class Director {
   public void direct(){
		//指定角色的饰演者
	   BEN ben = new LiuDeHua();
		//注入具体饰演者的剧本中
	   MoAttack moAttack = new MoAttack(ben);
	   moAttack.cityGateAsk();
   }
}

public class MoAttack {
	private GeLi geli;
  //属性注入方法
	public void setGeli(GeLi geli) {
		this.geli = geli;		
	}
	
	public void cityGateAsk() {
		geli.responseAsk("墨者革离");
	}
}
public class Director {
   public void direct(){
	   GeLi geli = new LiuDeHua();
	   MoAttack moAttack = new MoAttack();
	   //通过属性setGeli方法注入
		 moAttack.setGeli(geli);
	   moAttack.cityGateAsk();
   }
}

public interface ActorArrangable {
   void injectGeli(GeLi geli);
}

public class MoAttack implements ActorArrangable {
	private GeLi geli;

	public void injectGeli(GeLi geli) {
		this.geli = geli;		
	}
	
	public void cityGateAsk() {
		geli.responseAsk("墨者革离");
	}
}

<?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:p="<http://www.springframework.org/schema/p>"
	xsi:schemaLocation="<http://www.springframework.org/schema/beans> 
       <http://www.springframework.org/schema/beans/spring-beans-4.0.xsd>">
   <!--实现类实例化-->
   <bean id="geli" class="LiuDeHua"/>
   <bean id="moAttack" class="com.smart.ioc.MoAttack"
         p:geli-ref="geli"/> <!--通过geli-ref建立依赖关系-->
</beans>

package com.smart.reflect;
import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.lang.reflect.Method;

public class ReflectTest {
    public static Car initByDefaultConst() throws Throwable{
				//通过类装载器获取Car类对象
        
				//获取当前线程的ClassLoader
				ClassLoader loader = Thread.currentThread().getContextClassLoader();
        //通过指定的全限定类名“com.xxx...”装载Car类对应的反射实例
				Class<?> clazz = loader.loadClass("com.smart.reflect.Car");
				
		
				//获取类的默认构造器对象并通过它实例化Car
        
				//通过Car的反射类对象获取Car的构造函数对象cons
				Constructor<?> cons = clazz.getDeclaredConstructor((Class<?>[])null);
        //通过构造函数对象的newInstrance()方法实例化Car对象
				Car car = (Car)cons.newInstance();//效果等同于 new Car()
				
				//通过反射方法设置属性

				//通过Car的反射类对象的getMethod(String methodName，Class paramClass)
        //获取属性的setter方法对象，第一个参数为目标Class的方法名，第二个参数时方法入参的对象类型
        //接着通过invoke(Object obj,Object param)方法调用目标类的方法
				//第一个参数为操作的目标类对象实例，第二个参数时目标方法的入参
				Method setBrand = clazz.getMethod("setBrand",String.class);
        setBrand.invoke(car,"红旗CA72");
        Method setColor = clazz.getMethod("setColor",String.class);
        setColor.invoke(car,"黑色");
        Method setMaxSpeed = clazz.getMethod("setMaxSpeed",int.class);
        setMaxSpeed.invoke(car,200);
        return car;
    }
    public static void main(String[] args) throws Throwable{
        Car car = initByDefaultConst();
        car.introduce();
    }
}

Class loadClass(String name)
//name参数指定装载器需要装载类的名字，注意，必须使用全限定类名，如com.smart.beans.Car
//该方法有一个重载方法
Class loadClass(String name,boolean resolve)
//该方法告诉类装载器是否需要解析该类，如果JVM只需要知道该类是否存在或找出该类的超类，则不需要解析

Class defineClass(String name,byte[]b,int off,int len)
//将类文件的字节数组转换成JVM内部的java.lang.Class对象。
//字节数组可从本地文件、远程网络获取，参数name为字节数组对应的全限定类名

Class findSystemClass(String name)
//从本地文件载入Class文件，是JVM默认的装载机制

Class findLoadedClass(String name)
//调用该方法来查看是否已经装载某个类，如果已装载，则返回java.lang.Class对象，否则返回null

ClassLoader getParent();
//获取类装载器的父装载器

boolean exists(); //资源是否存在

boolean isOpen(); //资源是否打开

URL getURL() throws IOException; //如果底层资源可以表示成URL
	                               //则返回对应的URL对象
File getFile() throws IOException; //如果底层资源可以表示成文件
                                    //则返回对应的File对象
InputStream getInputStream() throws IOException; //返回资源对应的输入流

package com.smart.resource;

import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;

import org.springframework.core.io.*;

public class FileSourceExample {
	
	public static void main(String[] args) {
		try {
			String filePath = "G:/masterspring/wangpan/chapter4/src/main/resources/conf/file1.txt";
			//使用系统文件路径方式加载文件
			WritableResource res1 = new PathResource(filePath);
			//使用类路径方式加载文件
			Resource res2 = new ClassPathResource("conf/file1.txt");
			//使用WritableResource接口写资源文件
			OutputStream stream1 = res1.getOutputStream();
			stream1.write("WHO\\nARE\\nYOU".getBytes());
			stream1.close();
			//使用Resource接口读资源文件
            InputStream ins1 = res1.getInputStream();
			InputStream ins2 = res2.getInputStream();
			//二进制输出流
			ByteArrayOutputStream baos = new ByteArrayOutputStream();
			int i;
			//读取文件内容
			while((i=ins1.read())!=-1){
				baos.write(i);
			}
			//转换为string类型输出
			System.out.println(baos.toString());
   			//获取资源文件名
            System.out.println("res1:"+res1.getFilename());
            System.out.println("res2:"+res2.getFilename());            
		} catch (IOException e) {
			e.printStackTrace();
		}
	}
}

<%@ page language="java" contentType="text/html; charset=utf-8"
    pageEncoding="utf-8"%>
<jsp:directive.page import="org.springframework.web.context.support.ServletContextResource"/>
<jsp:directive.page import="org.springframework.core.io.Resource"/>
<jsp:directive.page import="org.springframework.web.util.WebUtils"/>
<%
   //注意文件资源地址以相对于Web应用根路径的方式表示
   Resource res3 = new ServletContextResource(application,"/WEB-INF/classes/conf/file1.txt");
   out.print(res3.getFilename()+"<br/>");
   out.print(WebUtils.getTempDir(application).getAbsolutePath());
%>

ListableBeanFactory //定义了访问容器中Bean基本信息的若干方法，如查看Bean个数等

HierarchicalBeanFactory // 父子级联IoC容器的接口，子容器可以通过接口方法访问父容器

ConfigurableBeanFactory //定义了设置类型装载器、属性编辑器、容器初始化后置处理器等方法

AutowireCapableBeanFactory //定义了将容器中的Bean按某种规则进行自动装配的方法

SingletonBeanRegistry //定义了允许在运行期间向容器注册单实例Bean的方法

BeanDefinitionRegistry //提供了向容器手工注册BeanDefinition对象的方法
				//Spring配置文件中每一个<bean>街道元素在Spring容器中通过一个BeanDefinition对象表示
		    //它描述了Bean的配置信息

//①下面两句装载配置文件并启动容器
 	   Resource res = new ClassPathResource("com/smart/beanfactory/beans.xml");

       BeanFactory bf= new DefaultListableBeanFactory();
       XmlBeanDefinitionReader reader = new XmlBeanDefinitionReader((DefaultListableBeanFactory)bf);
       reader.loadBeanDefinitions(res);

//④第一次从容器中获取car，将触发容器实例化该Bean，这将引发Bean生命周期方法的调用。
       Car car1 = (Car)bf.getBean("car");
       car1.introduce();
       car1.setColor("红色");

       //⑤第二次从容器中获取car，直接从缓存池中获取
       Car car2 = (Car)bf.getBean("car");

@Configuration
public class Beans {

	@Bean(name = "car")
	public Car buildCar() {
		Car car = new Car();
		car.setBrand("红旗CA72");
		car.setMaxSpeed(200);
		return car;
	}
}

public class AnnotationApplicationContext {

	 public static void main(String[] args) {
		//通过一个带@Configuration的POJO装载Bean配置
		ApplicationContext ctx = new AnnotationConfigApplicationContext(Beans.class);
		//该方法将加载Beans.class中的Bean定义并调用Beans.class中的方法实例化Bean
		Car car =ctx.getBean("car",Car.class);
	}
}

        <dependency>
            <groupId>org.hibernate</groupId>
            <artifactId>hibernate-validator</artifactId>
            <version>5.2.4.Final</version>
        </dependency>
   <!--springframework.web.servlet在spring-web中-->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-webmvc</artifactId>
            <version>4.2.5.RELEASE</version>
        </dependency>

<!-- 指定标注了Groovy的配置文件-->
    <context-param>
        <param-name>contextConfigLocation</param-name>
        <param-value>
            classpath:conf/spring-mvc.groovy
        </param-value>
    </context-param>

    <!-- ContextLoaderListener监听器将根据上面配置使用
         AnnotationConfigWebApplicationContext根据contextConfigLocation
         指定的配置类启动Spring容器-->
    <listener>
        <listener-class>
            org.springframework.web.context.ContextLoaderListener
        </listener-class>
    </listener>

<!--通过指定context参数，让Spring使用GroovyWebApplicationContext而非
    XmlWebApplicationContext或AnnotationConfigWebApplicationContext启动容器 -->
    <context-param>
        <param-name>contextClass</param-name>
        <param-value>
            org.springframework.web.context.support.GroovyWebApplicationContext
        </param-value>
    </context-param>

    <!-- 指定标注了Groovy的配置文件-->
    <context-param>
        <param-name>contextConfigLocation</param-name>
        <param-value>
            classpath:conf/spring-mvc.groovy
        </param-value>
    </context-param>

    <!-- ContextLoaderListener监听器将根据上面配置使用
         AnnotationConfigWebApplicationContext根据contextConfigLocation
         指定的配置类启动Spring容器-->
    <listener>
        <listener-class>
            org.springframework.web.context.ContextLoaderListener
        </listener-class>
    </listener>