java 反射和动态代理详解及实例代码
一、java中的反射
1.通过反射加载类的属性和方法实例代码:
/**
*java.lang.Class是反射的源头
*我们创建了一个类，通过编译（javac.exe）生成对应的class文件，之后我们通过java.exe加载(jvm的类加载器加载)此class文件
*此class文件加载到内存后，就是一个运行时类，存在缓存区，这个运行时类本事就是一个Class的实例
*每一个运行时类只加载一次，
*/
Class<StudentExam>clazz=StudentExam.class;
StudentExamstudentExam=clazz.newInstance();
System.err.println(studentExam);
System.out.println(clazz);
//Fieldfield=clazz.getField("id");//通过属性调用运行时类的指定属性：属性是public类型
Fieldfield=clazz.getDeclaredField("id");//属性是非public类型
Field[]fields=clazz.getDeclaredFields();//获取运行时类本身(父类不行)所有声明的属性，父类使用clazz.getFields();
for(Fieldfield2:fields){
inti=field2.getModifiers();
Stringtype=Modifier.toString(i);//获取字段属性的数据类型
System.out.println(type);
}
field.setAccessible(true);
field.set(studentExam,11);
System.err.println(studentExam.getId());
//通过反射调用运行时类的指定方法
Methodmethod=clazz.getMethod("setId",Integer.class);
method.invoke(studentExam,123);//调用运行时类的指定方法
Method[]methods=clazz.getMethods();//获取所有运行时类及其父类中所有声明为public的方法
Method[]methods2=clazz.getDeclaredMethods();//获取运行时类本身类中声明的方法
for(Methodmethod2:methods){
System.out.println(method2.getName());
}
//*通过对象的getClass()方法获取对象的运行时类，
Examexam=newExam();
ClassclazzExam=exam.getClass();
2.类加载器ClassLoader
/**
*Description:类加载器，加载xx.properties文件，并读取数据
*@param
*@authorxiazhongwei
*@data2016年9月29日:下午5:32:56
*@return
*/
publicvoidclassLoader()throwsIOException{
//方法一、从当前工程下加载
ClassLoaderloader=this.getClass().getClassLoader();
//路径是包下写：com\\able\\onlineExam\\resources\\config.properties
InputStreaminStream=loader.getResourceAsStream("config.properties");
//方法二、从指定的路径下加载文件
//FileInputStreamfileInputStream=newFileInputStream(newFile("config.properties"));
Propertiesproperties=newProperties();
properties.load(inStream);
//properties.load(fileInputStream);
Stringprop=properties.getProperty("domain");
System.out.println(prop);
}
3.动态代理
静态代理:代理类和目标对象的类型都是在编译期间确定下来，不利于程序的扩展。同时每个代理类只能为一个接口服务，这样一来程序开发中必然产生过多的代理。
动态代理:客户通过代理类来调用其他对象的方法，并且是在程序运行时，根据需要动态创建目标类的代理对象。
代理设计模式的原理：
使用一个代理将对象包装起来，然后用该代理对象取代原始对象，任何对原始对象的调用都要通过代理，代理对象决定的那个是否以及何时将方法调用
packagecom.test.junit;
importjava.lang.reflect.InvocationHandler;
importjava.lang.reflect.Method;
importjava.lang.reflect.Proxy;
publicclassProxyTest{
publicstaticvoidmain(String[]args){
RealSubjectrealSubject=newRealSubject();
MyInvocationHandlermyInvocationHandler=newMyInvocationHandler();
Objectobject=myInvocationHandler.bind(realSubject);
Subjectsubject=(Subject)object;
subject.action();
}
}
//动态代理的使用
interfaceSubject{
voidaction();
}
//被代理类
classRealSubjectimplementsSubject{
@Override
publicvoidaction(){
System.out.println("我是被代理类，记得执行我哦。。。。");
}
}
classMyInvocationHandlerimplementsInvocationHandler{
Objectobject;//实现了接口的被代理类的对象的声明
/**
*Description:①给被代理的对象实例化②返回一个代理类对象
*@param
*@authorxiazhongwei
*@data2016年9月29日:下午4:13:43
*@return
*/
publicObjectbind(Objectobject){
this.object=object;
returnProxy.newProxyInstance(object.getClass().getClassLoader(),object.getClass().getInterfaces(),this);
}
/**
*当通过代理类的对象发起对被重写的方法的调用时，都会转化为对如下的invok方法的调用
*/
@Override
publicObjectinvoke(Objectproxy,Methodmethod,Object[]args)
throwsThrowable{
ObjectreturnObject=method.invoke(object,args);
returnreturnObject;
}
}
4.动态代理与AOP
示例一、
packagecom.atguigu.spring.aop;
publicinterfaceArithmeticCalculator{
intadd(inti,intj);
intsub(inti,intj);
intmul(inti,intj);
intdiv(inti,intj);
}
packagecom.atguigu.spring.aop;
importorg.springframework.stereotype.Component;
@Component("arithmeticCalculator")
publicclassArithmeticCalculatorImplimplementsArithmeticCalculator{
@Override
publicintadd(inti,intj){
intresult=i+j;
returnresult;
}
@Override
publicintsub(inti,intj){
intresult=i-j;
returnresult;
}
@Override
publicintmul(inti,intj){
intresult=i*j;
returnresult;
}
@Override
publicintdiv(inti,intj){
intresult=i/j;
returnresult;
}
}
packagecom.atguigu.spring.aop;
publicclassArithmeticCalculatorLoggingImplimplementsArithmeticCalculator{
@Override
publicintadd(inti,intj){
System.out.println("Themethodaddbeginswith["+i+","+j+"]");
intresult=i+j;
System.out.println("Themethodaddendswith"+result);
returnresult;
}
@Override
publicintsub(inti,intj){
System.out.println("Themethodsubbeginswith["+i+","+j+"]");
intresult=i-j;
System.out.println("Themethodsubendswith"+result);
returnresult;
}
@Override
publicintmul(inti,intj){
System.out.println("Themethodmulbeginswith["+i+","+j+"]");
intresult=i*j;
System.out.println("Themethodmulendswith"+result);
returnresult;
}
@Override
publicintdiv(inti,intj){
System.out.println("Themethoddivbeginswith["+i+","+j+"]");
intresult=i/j;
System.out.println("Themethoddivendswith"+result);
returnresult;
}
}
packagecom.atguigu.spring.aop;
importjava.lang.reflect.InvocationHandler;
importjava.lang.reflect.Method;
importjava.lang.reflect.Proxy;
importjava.util.Arrays;
publicclassArithmeticCalculatorLoggingProxy{
//要代理的对象
privateArithmeticCalculatortarget;
publicArithmeticCalculatorLoggingProxy(ArithmeticCalculatortarget){
super();
this.target=target;
}
//返回代理对象
publicArithmeticCalculatorgetLoggingProxy(){
ArithmeticCalculatorproxy=null;
//代理对象有哪一个类加载器负责加载
ClassLoaderloader=target.getClass().getClassLoader();
//代理对象的类型，即其中有哪些方法
Class[]interfaces=newClass[]{ArithmeticCalculator.class};
//当调用代理对象的其中方法时，执行下面的代码
InvocationHandlerh=newInvocationHandler(){
/**
*proxy:代理对象。一般不使用该对象
*method:正在被调用的方法
*args:调用方法传入的参数
*/
@Override
publicObjectinvoke(Objectproxy,Methodmethod,Object[]args)
throwsThrowable{
//在方法内部不会直接调用proxy对象的某个方法，proxy.toString()会造成死循环调用invoke方法
StringmethodName=method.getName();
//打印日志
System.out.println("[before]Themethod"+methodName+"beginswith"+Arrays.asList(args));
//调用目标方法
Objectresult=null;
try{
//前置通知
result=method.invoke(target,args);
//返回通知,可以访问到方法的返回值
}catch(NullPointerExceptione){
e.printStackTrace();
//异常通知,可以访问到方法出现的异常
}
//后置通知.因为方法可以能会出异常,所以访问不到方法的返回值
//打印日志
System.out.println("[after]Themethodendswith"+result);
returnresult;
}
};
/**
*loader:代理对象使用的类加载器。
*interfaces:指定代理对象的类型.即代理代理对象中可以有哪些方法.
*h:当具体调用代理对象的方法时,应该如何进行响应,实际上就是调用InvocationHandler的invoke方法
*/
proxy=(ArithmeticCalculator)Proxy.newProxyInstance(loader,interfaces,h);
returnproxy;
}
}
packagecom.atguigu.spring.aop;
importorg.springframework.context.ApplicationContext;
importorg.springframework.context.support.ClassPathXmlApplicationContext;
publicclassMain{
publicstaticvoidmain(String[]args){
//ArithmeticCalculatorarithmeticCalculator=newArithmeticCalculatorImpl();
ArithmeticCalculatorarithmeticCalculator=newArithmeticCalculatorLoggingImpl();
arithmeticCalculator=newArithmeticCalculatorLoggingProxy(arithmeticCalculator).getLoggingProxy();
intresult=arithmeticCalculator.add(11,12);
System.out.println("result:"+result);
result=arithmeticCalculator.div(21,3);
System.out.println("result:"+result);
}
}
示例二、
packagecom.test.junit;
importjava.lang.reflect.InvocationHandler;
importjava.lang.reflect.Method;
importjava.lang.reflect.Proxy;
publicclassProxyTest{
publicstaticvoidmain(String[]args){
RealSubjectrealSubject=newRealSubject();
MyInvocationHandlermyInvocationHandler=newMyInvocationHandler();
Objectobject=myInvocationHandler.bind(realSubject);
Subjectsubject=(Subject)object;
subject.action();
}
}
//动态代理的使用
interfaceSubject{
voidaction();
}
//被代理类
classRealSubjectimplementsSubject{
@Override
publicvoidaction(){
System.out.println("我是被代理类，记得执行我哦。。。。");
}
}
classMyInvocationHandlerimplementsInvocationHandler{
Objectobject;//实现了接口的被代理类的对象的声明
/**
*Description:①给被代理的对象实例化②返回一个代理类对象
*@param
*@authorxiazhongwei
*@data2016年9月29日:下午4:13:43
*@return
*/
publicObjectbind(Objectobject){
this.object=object;
returnProxy.newProxyInstance(object.getClass().getClassLoader(),object.getClass().getInterfaces(),this);
}
/**
*当通过代理类的对象发起对被重写的方法的调用时，都会转化为对如下的invok方法的调用
*/
@Override
publicObjectinvoke(Objectproxy,Methodmethod,Object[]args)
throwsThrowable{
ObjectreturnObject=method.invoke(object,args);
returnreturnObject;
}
}
感谢阅读此文，希望能帮助到大家，谢谢大家对本站的支持！