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; } }
感谢阅读此文,希望能帮助到大家,谢谢大家对本站的支持!