反射最大的价值就是用来写框架，下面贴出自己的3篇代码，模拟实现SPING框架的bean工厂，IOC，AOP。当然这里重点是在利用反射实现功能，为了图方便，我用的是Properties文件，关于XML后面会有专门的博客来整理，到时候整合相关的解析XML的代码就可以了。
1，通过反射，读取配置文件来管理bean
package linkin; import java.io.FileInputStream;
import java.util.HashMap;
import java.util.Map;
import java.util.Properties; //这里就是通过反射，来获得对象的工厂
public class Linkin
{
// 定义一个对象池,前面是对象名，后面是实际对象
private Map<String ,Object> objectPool = new HashMap<String ,Object>();
// 定义一个创建对象的方法，该方法只要传入一个字符串类名，程序可以根据该类名生成Java对象
private Object createObject(String clazzName) throws Exception
{
// 根据字符串来获取对应的Class对象
Class<?> clazz = Class.forName(clazzName);
// 使用clazz对应类的默认构造器创建实例
return clazz.newInstance();
}
// 该方法根据指定文件来初始化对象池，它会根据配置文件来创建对象
public void initPool(String fileName) throws Exception
{
FileInputStream fis = null;
try
{
fis = new FileInputStream(fileName);
Properties props = new Properties();
props.load(fis);
for (String name : props.stringPropertyNames())//返回此属性列表中的键集
{
// 每取出一对key-value对，就根据value创建一个对象,调用createObject()创建对象，并将对象添加到对象池中
objectPool.put(name ,createObject(props.getProperty(name)));
}
}
catch (Exception ex)
{
System.out.println("读取" + fileName + "异常");
}
finally
{
if(null != fis)
{
fis.close();
}
} }
public Object getObject(String name)
{
// 从objectPool中取出指定name对应的对象。
return objectPool.get(name);
} public static void main(String[] args)
throws Exception
{
Linkin linkin = new Linkin();
linkin.initPool("Linkin.txt");//linkin=linkin.Linkin
System.out.println(linkin.getObject("linkin"));
}
}
2，通过反射实现IOC注入功能
package linkin; import java.io.FileInputStream;
import java.io.IOException;
import java.lang.reflect.Method;
import java.util.HashMap;
import java.util.Map;
import java.util.Properties; public class Linkin
{
private String name; public String getName()
{
return name;
}
public void setName(String name)
{
this.name = name;
}
// 定义一个对象池,前面是对象名，后面是实际对象
private Map<String ,Object> objectPool = new HashMap<String ,Object>();
private Properties config = new Properties();
// 从指定属性文件中初始化Properties对象。
public void init(String fileName) throws Exception
{
FileInputStream fis = null;
try
{
fis = new FileInputStream(fileName);
config.load(fis);
}
catch (IOException ex)
{
System.out.println("读取" + fileName + "异常");
}
finally
{
if(null != fis){
fis.close();
}
}
}
// 定义一个创建对象的方法，该方法只要传入一个字符串类名，程序可以根据该类名生成Java对象
private Object createObject(String clazzName) throws Exception
{
// 根据字符串来获取对应的Class对象
Class<?> clazz =Class.forName(clazzName);
// 使用clazz对应类的默认构造器创建实例，这一行道出了javabean的精髓，为什么javabean规范中要就有一个默认的无参的构造器
return clazz.newInstance();
}
// 该方法根据指定文件来初始化对象池，它会根据配置文件来创建对象
public void initPool() throws Exception
{
for (String name : config.stringPropertyNames())
{
// 每取出一对key-value对，如果key中不包含百分号（%）
// 这个就标明是根据value来创建一个对象
// 调用createObject创建对象，并将对象添加到对象池中
if (!name.contains("%"))
{
objectPool.put(name , createObject(config.getProperty(name)));
}
}
}
// 该方法根据指定文件来初始化对象池，它会根据配置文件来创建对象
public void initProperty()throws Exception
{
for (String name : config.stringPropertyNames())
{
// 每取出一对key-value对，如果key中包含百分号（%）
// 即可认为该key是用于为对象的Field设置值，
// %前半为对象名字，后半为Field名
// 程序将调用对应的setter方法来为对应Field设置值。
if (name.contains("%"))
{
// 将配置文件中key按%分割
String[] objAndProp = name.split("%");
// 取出需要设置Field值的目标对象
Object target = getObject(objAndProp[0]);
// 该Field对应的setter方法名:set + "属性的首字母大写" + 剩下部分
String mtdName = "set" + objAndProp[1].substring(0 , 1).toUpperCase() + objAndProp[1].substring(1);
// 通过target的getClass()获取它实现类所对应的Class对象
Class<?> targetClass = target.getClass();
// 获取该属性对应的setter方法，下面这一行道出了springIOC的精髓，为什么实现XML我们每次都要提供get和set方法，除了注解的哦
Method mtd = targetClass.getMethod(mtdName , String.class);
// 通过Method的invoke方法执行setter方法，将config.getProperty(name)的属性值作为调用setter的方法的实参
mtd.invoke(target , config.getProperty(name));
}
}
}
public Object getObject(String name)
{
// 从objectPool中取出指定name对应的对象。
return objectPool.get(name);
}
public static void main(String[] args)throws Exception
{
Linkin linkin = new Linkin();
linkin.init("Linkin.txt");//linkin=linkin.Linkin
//linkin%name=LinkinPark...
linkin.initPool();
linkin.initProperty();
linkin = (Linkin) linkin.getObject("linkin");
System.out.println(linkin.getName());
}
}
3，通过反射实现AOP框架，并且跑了代理，（人为可以控制跑不跑代理）。
package linkin; import java.io.FileInputStream;
import java.io.IOException;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
import java.util.HashMap;
import java.util.Map;
import java.util.Properties; public class Linkin implements Person
{
private String name; public String getName()
{
return name;
}
public void setName(String name)
{
this.name = name;
}
//定义这个方法来作为测试
public void test()
{
System.out.println("这里是原始的方法");
}
// 定义一个对象池,前面是对象名，后面是实际对象
private Map<String ,Object> objectPool = new HashMap<String ,Object>();
private Properties config = new Properties();
// 从指定属性文件中初始化Properties对象。
public void init(String fileName) throws Exception
{
FileInputStream fis = null;
try
{
fis = new FileInputStream(fileName);
config.load(fis);
}
catch (IOException ex)
{
System.out.println("读取" + fileName + "异常");
}
finally
{
if(null != fis){
fis.close();
}
}
}
// 定义一个创建对象的方法，该方法只要传入一个字符串类名，程序可以根据该类名生成Java对象
private Object createObject(String clazzName) throws Exception
{
// 根据字符串来获取对应的Class对象
Class<?> clazz = Class.forName(clazzName);
// 使用clazz对应类的默认构造器创建实例，这一行道出了javabean的精髓，为什么javabean规范中要就有一个默认的无参的构造器
return clazz.newInstance();
}
// 该方法根据指定文件来初始化对象池，它会根据配置文件来创建对象
public void initPool() throws Exception
{
for (String name : config.stringPropertyNames())
{
// 每取出一对key-value对，如果key中不包含百分号（%），这个就标明是根据value来创建一个对象，调用createObject创建对象，并将对象添加到对象池中
// 如果他是我们自己定义的LinkinProxy，就说明这里是跑代理的，不然就是不跑代理的
String className = config.getProperty(name);
if (!name.contains("%") && !name.contains("."))
{
Object bean = createObject(className);
if(bean instanceof LinkinProxy)
{
LinkinProxy linkinProxyBean = (LinkinProxy) bean;
LinkinAdvice linkinAdvice = (LinkinAdvice) createObject(config.getProperty(name + ".advice"));
Object target = createObject(config.getProperty(name + ".target"));
initProperty(target);
linkinProxyBean.setLinkinAdvice(linkinAdvice);
linkinProxyBean.setTarget(target);
bean = linkinProxyBean.getProxyBean();
}
else
{
initProperty(bean);
}
objectPool.put(name , bean);
}
}
}
// 该方法根据指定文件来初始化对象池，它会根据配置文件来创建对象
public void initProperty(Object target)throws Exception
{
for (String name : config.stringPropertyNames())
{
// 每取出一对key-value对，如果key中包含百分号（%）
// 即可认为该key是用于为对象的Field设置值，
// %前半为对象名字，后半为Field名
// 程序将调用对应的setter方法来为对应Field设置值。
if (name.contains("%"))
{
// 将配置文件中key按%分割
String[] objAndProp = name.split("%");
// 取出需要设置Field值的目标对象，这里加一个控制，如果他是代理的话，就不能从池里面去取le
//Object target = getObject(objAndProp[0]);
// 该Field对应的setter方法名:set + "属性的首字母大写" + 剩下部分
String mtdName = "set" + objAndProp[1].substring(0 , 1).toUpperCase() + objAndProp[1].substring(1);
// 通过target的getClass()获取它实现类所对应的Class对象。
Class<?> targetClass = target.getClass();
// 获取该属性对应的setter方法，下面这一行道出了springIOC的精髓，为什么实现XML我们每次都要提供get和set方法，除了注解的哦
Method mtd = targetClass.getMethod(mtdName , String.class);
// 通过Method的invoke方法执行setter方法，将config.getProperty(name)的属性值作为调用setter的方法的实参
mtd.invoke(target , config.getProperty(name));
}
}
}
public Object getObject(String name)
{
// 从objectPool中取出指定name对应的对象。
return objectPool.get(name);
}
public static void main(String[] args)throws Exception
{
Linkin linkin = new Linkin();
linkin.init("Linkin.txt");
linkin.initPool();
Person huhu = (Person) linkin.getObject("XXX");
System.out.println(huhu.getClass());
huhu.test();
}
} class LinkinProxy
{
private Object target;//原始对象
private LinkinAdvice linkinAdvice;//服务 public LinkinAdvice getLinkinAdvice()
{
return linkinAdvice;
} public void setLinkinAdvice(LinkinAdvice linkinAdvice)
{
this.linkinAdvice = linkinAdvice;
} public Object getTarget()
{
return target;
} public void setTarget(Object target)
{
this.target = target;
} public Object getProxyBean()
{
LinkinInvocationHandler linkinInvocationHandler = new LinkinInvocationHandler();
linkinInvocationHandler.setTarget(target);
linkinInvocationHandler.setLinkinAdvice(linkinAdvice);
Object proxyBean = Proxy.newProxyInstance(target.getClass().getClassLoader(), target.getClass().getInterfaces(),
linkinInvocationHandler);
return proxyBean;
}
} //定义接口
interface Person
{
void test();
}
interface LinkinAdvice
{
public void test();
public void test1();
}
//定义服务1
class LinkinAdvice1 implements LinkinAdvice
{
public void test()
{
System.out.println("这里是第1个通用的方法。。。");
}
public void test1()
{
System.out.println("这里是第2个通用的方法");
}
}
//定义服务2
class LinkinAdvice2 implements LinkinAdvice
{
public void test()
{
System.out.println("这里是第3个通用的方法。。。");
}
public void test1()
{
System.out.println("这里是第4个通用的方法");
}
} class LinkinInvocationHandler implements InvocationHandler
{
private Object target; private LinkinAdvice linkinAdvice;//服务 public Object getTarget()
{
return target;
} public void setTarget(Object target)
{
this.target = target;
} public LinkinAdvice getLinkinAdvice()
{
return linkinAdvice;
} public void setLinkinAdvice(LinkinAdvice linkinAdvice)
{
this.linkinAdvice = linkinAdvice;
} @Override
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable
{
linkinAdvice.test();
Object result = method.invoke(target, args);
linkinAdvice.test1();
return result;
} }
#一下配置文件的说明：要是直接生成原始对象就直接指定全限定类名就好了，要是想跑代理就指定下面那个名字，然后设置服务和原始对象#
#下面的属性注入模拟了IOC功能，不管是代理对象还是原始对象，都可以把这个属性值注入，原始对象就是注入原始对象，代理对象就是注入到被代理的那个原始对象中#
#XXX=linkin.Linkin
##以这个作为控制，要是得到的类放完反射属于这个类，那么就认为是要代理，不然就是不代理#
XXX=linkin.LinkinProxy
#模拟了属性注入，XML是通过自己的标签，这里我自己使用“%”模拟了下#
XXX%name=LinkinPark...
#这里是代理对象的服务，也就是AOP中插入的通用服务代码，可以随便切换，自己定义个服务，这里配上就可以用了#
XXX.advice=linkin.LinkinAdvice2
#这里就是上面那个代理类的原始对象#
XXX.target=linkin.Linkin
