2.如果是没有接口声明的类呢,反射就像镜子

2019-09-29 21:45 来源:未知

Object类的getClass的用法: **

一.概念

  反射就是把Java的各种成分映射成相应的Java类。

  Class类的构造方法是private,由JVM创建。

  反射是java语言的一个特性,它允程序在运行时(注意不是编译的时候)来进行自我检查并且对内部的成员进行操作。例如它允许一个java的类获取他所有的成员变量和方法并且显示出来。Java 的这一能力在实际应用中也许用得不是很多,但是在其它的程序设计语言中根本就不存在这一特性。例如,Pascal、C 或者 C++ 中就没有办法在程序中获得函数定义相关的信息。 (来自Sun)

  JavaBean 是 reflection 的实际应用之一,它能让一些工具可视化的操作软件组件。这些工具通过 reflection 动态的载入并取得 Java 组件(类) 的属性。

  反射是从1.2就有的,后面的三大框架都会用到反射机制,涉及到类"Class",无法直接new CLass(),其对象是内存里的一份字节码.  

  Class 类的实例表示正在运行的 Java 应用程序中的类和接口。枚举是一种类,注释是一种接口。每个数组属于被映射为 Class 对象的一个类,所有具有相同元素类型和维数的数组都共享该 Class 对象。基本的 Java类型(boolean、byte、char、short、int、long、float 和 double)和关键字 void 也表示为 Class 对象。Class 没有公共构造方法。Class 对象是在加载类时由 Java 虚拟机以及通过调用类加载器中的 defineClass 方法自动构造的。 

1 Person p1 = new Person();
2 //下面的这三种方式都可以得到字节码
3 CLass c1 = Date.class();
4 p1.getClass(); 
5 //若存在则加载,否则新建,往往使用第三种,类的名字在写源程序时不需要知道,到运行时再传递过来
6 Class.forName("java.lang.String");

  CLass.forName()字节码已经加载到java虚拟机中,去得到字节码;java虚拟机中还没有生成字节码 用类加载器进行加载,加载的字节码缓冲到虚拟机中。 

  考虑下面这个简单的例子,让我们看看 reflection 是如何工作的。

import java.lang.reflect.*;  

public class DumpMethods {  

   public static void main(String args[]) {  

      try {  

           Class c = Class.forName("java.util.Stack");  

           Method m[] = c.getDeclaredMethods();  

             

           for (int i = 0; i < m.length; i++)  

               System.out.println(m[i].toString());  

      }  

      catch (Throwable e){  

            System.err.println(e);  

      }  

   }  

}

 

1 public synchronized java.lang.Object java.util.Stack.pop() 
2 public java.lang.Object java.util.Stack.push(java.lang.Object) 
3 public boolean java.util.Stack.empty() 
4 public synchronized java.lang.Object java.util.Stack.peek() 
5 public synchronized int java.util.Stack.search(java.lang.Object)

  这样就列出了java.util.Stack 类的各方法名以及它们的限制符和返回类型。这个程序使用 Class.forName 载入指定的类,然后调用 getDeclaredMethods 来获取这个类中定义了的方法列表。java.lang.reflect.Methods 是用来描述某个类中单个方法的一个类。

  以下示例使用 Class 对象来显示对象的类名:

1 void printClassName(Object obj) {
2          System.out.println("The class of " + obj +
3                             " is " + obj.getClass().getName());
4      }

  还可以使用一个类字面值(JLS Section 15.8.2)来获取指定类型(或 void)的 Class 对象。例如:

1 System.out.println("The name of class Foo is: "+Foo.class.getName());

   在没有对象实例的时候,主要有两种办法。

//获得类类型的两种方式        

Class cls1 = Role.class;        

Class cls2 = Class.forName("yui.Role");

  注意第二种方式中,forName中的参数一定是完整的类名(包名+类名),并且这个方法需要捕获异常。现在得到cls1就可以创建一个Role类的实例了,利用Class的newInstance方法相当于调用类的默认的构造器。

1 Object o = cls1.newInstance(); 
2 //创建一个实例        
3 //Object o1 = new Role();   //与上面的方法等价

Spring AOP两种实现机制是什么?

Spring

<iframe id="iframeu788097_0" src="" width="336" height="280" align="center,center" vspace="0" hspace="0" marginwidth="0" marginheight="0" scrolling="no" frameborder="0" allowtransparency="true" style="border-width: 0px; border-style: initial; vertical-align: bottom; margin: 0px;"></iframe>

SPRING是通过动态代理来实现AOP的,SPRING内部提供了2种实现机制
1.如果是有接口声明的类进行AOP,spring调用的是java.lang.reflection.Proxy类来做处理

org.springframework.aop.framework.JdkDynamicAopProxy

       public Object getProxy(ClassLoader classLoader) {

              if (logger.isDebugEnabled()) {

                     Class targetClass = this.advised.getTargetSource().getTargetClass();

                     logger.debug(“Creating JDK dynamic proxy” +

                                   (targetClass != null ? ” for [" + targetClass.getName() + "]” : “”));

              }

              Class[] proxiedInterfaces = AopProxyUtils.completeProxiedInterfaces(this.advised);

              return Proxy.newProxyInstance(classLoader, proxiedInterfaces, this);

       }

org.springframework.aop.framework.ReflectiveMethodInvocation

public Object proceed() throws Throwable {

              //     We start with an index of -1 and increment early.

              if (this.currentInterceptorIndex == this.interceptorsAndDynamicMethodMatchers.size() – 1) {

                     return invokeJoinpoint();

              }

              Object interceptorOrInterceptionAdvice =

                  this.interceptorsAndDynamicMethodMatchers.get(++this.currentInterceptorIndex);

              if (interceptorOrInterceptionAdvice instanceof InterceptorAndDynamicMethodMatcher) {

                     // Evaluate dynamic method matcher here: static part will already have

                     // been evaluated and found to match.

                     InterceptorAndDynamicMethodMatcher dm =

                         (InterceptorAndDynamicMethodMatcher) interceptorOrInterceptionAdvice;

                     if (dm.methodMatcher.matches(this.method, this.targetClass, this.arguments)) {

                            return dm.interceptor.invoke(this);

                     }

                     else {

                            // Dynamic matching failed.

                            // Skip this interceptor and invoke the next in the chain.

                            return proceed();

                     }

              }

              else {

                     // It’s an interceptor, so we just invoke it: The pointcut will have

                     // been evaluated statically before this object was constructed.

                     return ((MethodInterceptor) interceptorOrInterceptionAdvice).invoke(this);

              }

       }

2.如果是没有接口声明的类呢?SPRING通过CGLIB包和内部类来实现

private static class StaticUnadvisedInterceptor implements MethodInterceptor, Serializable {

 

private final Object target;

 

public StaticUnadvisedInterceptor(Object target) {

this.target = target;

}

 

public Object intercept(Object proxy, Method method, Object[] args,

MethodProxy methodProxy) throws Throwable {

 

Object retVal = methodProxy.invoke(target, args);

return massageReturnTypeIfNecessary(proxy, target, retVal);

}

}

 

 

/**

* Method interceptor used for static targets with no advice chain, when the

* proxy is to be exposed.

*/

private static class StaticUnadvisedExposedInterceptor implements MethodInterceptor, Serializable {

 

private final Object target;

 

public StaticUnadvisedExposedInterceptor(Object target) {

this.target = target;

}

 

public Object intercept(Object proxy, Method method, Object[] args, MethodProxy methodProxy) throws Throwable {

Object oldProxy = null;

try {

oldProxy = AopContext.setCurrentProxy(proxy);

Object retVal = methodProxy.invoke(target, args);

return massageReturnTypeIfNecessary(proxy, target, retVal);

}

finally {

AopContext.setCurrentProxy(oldProxy);

}

}

}

 

 

/**

* Interceptor used to invoke a dynamic target without creating a method

* invocation or evaluating an advice chain. (We know there was no advice

* for this method.)

*/

private class DynamicUnadvisedInterceptor implements MethodInterceptor, Serializable {

 

public Object intercept(Object proxy, Method method, Object[] args, MethodProxy methodProxy) throws Throwable {

Object target = advised.getTargetSource().getTarget();

try {

Object retVal = methodProxy.invoke(target, args);

return massageReturnTypeIfNecessary(proxy, target, retVal);

}

finally {

advised.getTargetSource().releaseTarget(target);

}

}

}

 

 

/**

* Interceptor for unadvised dynamic targets when the proxy needs exposing.

*/

private class DynamicUnadvisedExposedInterceptor implements MethodInterceptor, Serializable {

 

public Object intercept(Object proxy, Method method, Object[] args, MethodProxy methodProxy) throws Throwable {

Object oldProxy = null;

Object target = advised.getTargetSource().getTarget();

try {

oldProxy = AopContext.setCurrentProxy(proxy);

Object retVal = methodProxy.invoke(target, args);

return massageReturnTypeIfNecessary(proxy, target, retVal);

}

finally {

AopContext.setCurrentProxy(oldProxy);

advised.getTargetSource().releaseTarget(target);

}

}

}

 

我们自己也可以来试试
1.jdk proxy方式

先来一个接口
IHelloWorld.java

package kris.aop.test;

 

public interface IHelloWorld {

 

public void print(String name);

public void write(String sth);

}

 

再来一个实现

HelloWorld.java

package kris.aop.test;

 

public class HelloWorld implements IHelloWorld {

 

public void print(String name){

System.out.println(“HelloWorld “+name);

}

 

public void write(String sth) {

System.out.println(“write “+sth);

}

 

}

 

代理类

DefaultInvocationHandler.java

package kris.aop.test;

 

import java.lang.reflect.InvocationHandler;

import java.lang.reflect.Method;

 

public class DefaultInvocationHandler implements InvocationHandler {

 

/**

* 替换外部class调用的方法

* obj                 外部已经已经包装好InvocationHandler的实例

* method        外部方法

* args              方法参数

*/

public Object invoke(Object obj, Method method, Object[] args)

throws Throwable {

String s1 []={“kris”};

String s2 []={“anyone”};

IHelloWorld ihw=new HelloWorld();

System.out.println(“start!”);

method.invoke(ihw,args);

method.invoke(ihw,s1);

Object o=method.invoke(ihw,s2);

System.out.println(“stop!”);

return o;

}

}

 

测试类
Test.java

package kris.aop.test;

 

import java.lang.reflect.InvocationHandler;

import java.lang.reflect.Proxy;

 

public class Test {

 

public static void main(String args []){

Class clazz = new HelloWorld().getClass();

ClassLoader cl = clazz.getClassLoader();

Class classes [] = clazz.getInterfaces();

InvocationHandler ih=new DefaultInvocationHandler();

//用InvocationHandler给HelloWorld进行AOP包装

IHelloWorld ihw=(IHelloWorld) Proxy.newProxyInstance(cl,classes,ih);

ihw.print(“test”);

ihw.write(“test”);

}

}

 

2.用CGLIB包实现,首先不要忘了引入那个包

package kris.aop.cglib.test;

 

public class HelloWorld {

 

public void print(String name){

System.out.println(“HelloWorld “+name);

}

 

public void write(String sth) {

System.out.println(“write “+sth);

}

public void print(){

System.out.println(“HelloWorld”);

}

}

 

代理类(没用内部类,看起来清楚点)

package kris.aop.cglib.test;

 

import java.lang.reflect.Method;

 

import net.sf.cglib.proxy.MethodInterceptor;

import net.sf.cglib.proxy.MethodProxy;

 

public class MethodInterceptorImpl implements MethodInterceptor {

 

public Object intercept(Object obj, Method method, Object[] args,

MethodProxy proxy) throws Throwable {

 

System.out.println(method);

 

proxy.invokeSuper(obj, args);

 

return null;

}

}

 

测试类

 

package kris.aop.cglib.test;

 

import net.sf.cglib.proxy.Enhancer;

 

public class Test {

 

public static void main(String[] args) {

 

Enhancer enhancer = new Enhancer();

 

enhancer.setSuperclass(HelloWorld.class);

//设置回调方法实现类

enhancer.setCallback(new MethodInterceptorImpl());

//实例化已经添加回调实现的HELLOWORLD实例

HelloWorld my = (HelloWorld) enhancer.create();

 

my.print();

}

 

}

Object类中有一个getClass方法,m a r k- t o- w i n:它会返回一个你的对象所对应的一个Class的对象,这个返回来的对象保存着你的原对象的类信息,比如你的原对象的类名叫什么,类里有什么方法,字段等。在高级编程当中用的很多,和反射相关。马克-to-win:现在这个阶段还说不清楚,只能先打个比方,反射就像镜子,你觉得生活当中的镜子有用吗? 

二.常用方法  

  1.isPrimitive(判断是否是基本类型的字节码)

public class TestReflect {

    public static void main(String[] args) {

        // TODO Auto-generated method stub

        String str = "abc";

        Class cls1 = str.getClass();

        Class cls2 = String.class;

        Class cls3 = null;//必须要加上null

        try {

            cls3 = Class.forName("java.lang.String");

        } catch (ClassNotFoundException e) {

            // TODO Auto-generated catch block

            e.printStackTrace();

        }

        System.out.println(cls1==cls2);

        System.out.println(cls1==cls3);

        

        System.out.println(cls1.isPrimitive());

        System.out.println(int.class.isPrimitive());//判定指定的 Class 对象是否表示一个基本类型。

        System.out.println(int.class == Integer.class);

        System.out.println(int.class == Integer.TYPE);

        System.out.println(int[].class.isPrimitive());

        System.out.println(int[].class.isArray());

    }

}

/*

 * true

true

false

true

false

true

false

true

 */

*/

  2.getConstructor和getConstructors()

  java中构造方法没有先后顺序,通过类型和参数个数区分。 

public class TestReflect {

    public static void main(String[] args) throws SecurityException, NoSuchMethodException {

        // TODO Auto-generated method stub

        String str = "abc";

        

        System.out.println(String.class.getConstructor(StringBuffer.class));

    }

}

  3.Filed类代表某一类中的一个成员变量。

import java.lang.reflect.Field;

public class TestReflect {

    public static void main(String[] args) throws SecurityException, NoSuchMethodException, NoSuchFieldException, IllegalArgumentException, Exception {

        ReflectPointer rp1 = new ReflectPointer(3,4);

        Field fieldx = rp1.getClass().getField("x");//必须是x或者y

        System.out.println(fieldx.get(rp1));

        

        /*

         * private的成员变量必须使用getDeclaredField,并setAccessible(true),否则看得到拿不到

         */

        Field fieldy = rp1.getClass().getDeclaredField("y");

        fieldy.setAccessible(true);//暴力反射

        System.out.println(fieldy.get(rp1));

        

    }

}

class ReflectPointer {

    

    public int x = 0;

    private int y = 0;

    

    public ReflectPointer(int x,int y) {//alt + shift +s相当于右键source

        super();

        // TODO Auto-generated constructor stub

        this.x = x;

        this.y = y;

    }

}

例2.1.3---**本章源码**

三.典型例题

  1.将所有String类型的成员变量里的b改成a。

import java.lang.reflect.Field;

public class TestReflect {

    public static void main(String[] args) throws SecurityException, NoSuchMethodException, NoSuchFieldException, IllegalArgumentException, Exception {

        ReflectPointer rp1 = new ReflectPointer(3,4);

        changeBtoA(rp1);

        System.out.println(rp1);

        

    }

    

    private static void changeBtoA(Object obj) throws RuntimeException, Exception {

        Field[] fields = obj.getClass().getFields();

        

        for(Field field : fields) {

            //if(field.getType().equals(String.class))

            //由于字节码只有一份,用equals语义不准确

            if(field.getType()==String.class) {

                String oldValue = (String)field.get(obj);

                String newValue = oldValue.replace('b', 'a');

                field.set(obj,newValue);

            }

        }

    }

}

class ReflectPointer {

    

    private int x = 0;

    public int y = 0;

    public String str1 = "ball";

    public String str2 = "basketball";

    public String str3 = "itcat";

    

    public ReflectPointer(int x,int y) {//alt + shift +s相当于右键source

        super();

        // TODO Auto-generated constructor stub

        this.x = x;

        this.y = y;

    }

    @Override

    public String toString() {

        return "ReflectPointer [str1=" + str1 + ", str2=" + str2 + ", str3="

                + str3 + "]";

    }

}

  2.写一个程序根据用户提供的类名,调用该类的里的main方法。

  为什么要用反射的方式呢?

import java.lang.reflect.Field;

import java.lang.reflect.Method;

public class TestReflect {

    public static void main(String[] args) throws SecurityException, NoSuchMethodException, NoSuchFieldException, IllegalArgumentException, Exception {

        String str = args[0];

        /*

         * 这样会数组角标越界,因为压根没有这个字符数组

         * 需要右键在run as-configurations-arguments里输入b.Inter(完整类名)

         * 

         */

        Method m = Class.forName(str).getMethod("main",String[]www.129028.com,.class);

        //下面这两种方式都可以,main方法需要一个参数

        

        m.invoke(null, new Object[]{new String[]{"111","222","333"}});

        m.invoke(null, (Object)new String[]{"111","222","333"});//这个可以说明,数组也是Object

        /*

         * m.invoke(null, new String[]{"111","222","333"})

         * 上面的不可以,因为java会自动拆包

         */

    }

}

class Inter {

    public static void main(String[] args) {

        for(Object obj : args) {

            System.out.println(obj);

        }

    }

}

  3.模拟 instanceof 操作符

class S {  

}   

public class IsInstance {  

   public static void main(String args[]) {  

      try {  

           Class cls = Class.forName("S");  

           boolean b1 = cls.isInstance(new Integer(37));  

           System.out.println(b1);  

           boolean b2 = cls.isInstance(new S());  

           System.out.println(b2);  

      }  

      catch (Throwable e) {  

           System.err.println(e);  

      }  

   }  

}

  在这个例子中创建了一个S 类的 Class 对象,然后检查一些对象是否是S的实例。Integer(37) 不是,但 new S()是。

TAG标签:
版权声明:本文由www.129028.com-澳门金沙唯一官网www129028com发布于编程新闻,转载请注明出处:2.如果是没有接口声明的类呢,反射就像镜子