欢迎您访问程序员文章站本站旨在为大家提供分享程序员计算机编程知识!
您现在的位置是: 首页  >  IT编程

java 反射和动态代理详解及实例代码

程序员文章站 2024-03-12 15:42:14
一、java中的反射 1.通过反射加载类的属性和方法实例代码: /** * java.lang.class 是反射的源头 * 我们创...

一、java中的反射

1.通过反射加载类的属性和方法实例代码:

/**
     * java.lang.class 是反射的源头
     * 我们创建了一个类,通过编译(javac.exe)生成对应的class文件,之后我们通过java.exe加载(jvm的类加载器加载)此class文件
     * 此class文件加载到内存后,就是一个运行时类,存在缓存区,这个运行时类本事就是一个class的实例
     * 每一个运行时类只加载一次,
     */
    class<studentexam> clazz = studentexam.class;
    studentexam studentexam = clazz.newinstance();
    system.err.println(studentexam);
     
    system.out.println(clazz);
    // field field = clazz.getfield("id"); // 通过属性调用运行时类的指定属性:属性是public类型
    field field = clazz.getdeclaredfield("id"); // 属性是非public 类型
    field[] fields = clazz.getdeclaredfields(); // 获取运行时类本身(父类不行)所有声明的属性,父类使用clazz.getfields();
    for (field field2 : fields) {
      int i = field2.getmodifiers();
      string type = modifier.tostring(i);// 获取字段属性的数据类型
      system.out.println(type);
    }
    field.setaccessible(true);
    field.set(studentexam, 11);
    system.err.println(studentexam.getid());
     
    // 通过反射调用运行时类的指定方法
    method method = clazz.getmethod("setid", integer.class);
    method.invoke(studentexam, 123); // 调用运行时类的指定方法
    method[] methods = clazz.getmethods(); // 获取所有运行时类及其父类中所有声明为public的方法
    method[] methods2 = clazz.getdeclaredmethods();// 获取运行时类本身类中声明的方法
    for (method method2 : methods) {
      system.out.println(method2.getname());
    }
     
    // * 通过对象的getclass()方法获取对象的运行时类,
    exam exam = new exam();
    class clazzexam = exam.getclass();

2.类加载器classloader

/**
   * description:类加载器,加载xx.properties文件,并读取数据
   * @param
   * @author xiazhongwei
   * @data 2016年9月29日:下午5:32:56
   * @return
   */
  public void classloader() throws ioexception {
    //方法一、从当前工程下加载
    classloader loader = this.getclass().getclassloader();
    // 路径是包下写:com\\able\\onlineexam\\resources\\config.properties
    inputstream instream = loader.getresourceasstream("config.properties");
    // 方法二、从指定的路径下加载文件
    // fileinputstream fileinputstream = new fileinputstream(new file("config.properties"));
     
    properties properties = new properties();
    properties.load(instream);
    // properties.load(fileinputstream);
    string prop = properties.getproperty("domain");
    system.out.println(prop);
  }

3.动态代理

静态代理:代理类和目标对象的类型都是在编译期间确定下来,不利于程序的扩展。同时每个代理类只能为一个接口服务,这样一来程序开发中必然产生过多的代理。

动态代理:客户通过代理类来调用其他对象的方法,并且是在程序运行时,根据需要动态创建目标类的代理对象。

代理设计模式的原理:

使用一个代理将对象包装起来,然后用该代理对象取代原始对象,任何对原始对象的调用都要通过代理,代理对象决定的那个是否以及何时将方法调用

package com.test.junit;
 
import java.lang.reflect.invocationhandler;
import java.lang.reflect.method;
import java.lang.reflect.proxy;
 
public class proxytest {
 
  public static void main(string[] args) {
    realsubject realsubject = new realsubject();
    myinvocationhandler myinvocationhandler = new myinvocationhandler();
    object object = myinvocationhandler.bind(realsubject);
    subject subject = (subject) object;
    subject.action();
  }
}
// 动态代理的使用
interface subject{
  void action();
}
// 被代理类
class realsubject implements subject{
 
  @override
  public void action() {
 
    system.out.println("我是被代理类,记得执行我哦。。。。");
  }
   
}
 
class myinvocationhandler implements invocationhandler{
 
  object object;// 实现了接口的被代理类的对象的声明
  /**
   * description:①给被代理的对象实例化 ②返回一个代理类对象
   * @param
   * @author xiazhongwei
   * @data 2016年9月29日:下午4:13:43
   * @return
   */
  public object bind(object object){
    this.object = object;
    return proxy.newproxyinstance(object.getclass().getclassloader(), object.getclass().getinterfaces(), this);
  }
  /**
   * 当通过代理类的对象发起对被重写的方法的调用时,都会转化为对如下的invok方法的调用
   */
  @override
  public object invoke(object proxy, method method, object[] args)
      throws throwable {
    object returnobject = method.invoke(object, args);
    return returnobject;
  }
}

4.动态代理与aop

 示例一、

package com.atguigu.spring.aop;
 
public interface arithmeticcalculator {
  int add(int i, int j);
  int sub(int i, int j);
   
  int mul(int i, int j);
  int div(int i, int j);
}
 package com.atguigu.spring.aop;
 
import org.springframework.stereotype.component;
 
@component("arithmeticcalculator")
public class arithmeticcalculatorimpl implements arithmeticcalculator {
 
  @override
  public int add(int i, int j) {
    int result = i + j;
    return result;
  }
 
  @override
  public int sub(int i, int j) {
    int result = i - j;
    return result;
  }
 
  @override
  public int mul(int i, int j) {
    int result = i * j;
    return result;
  }
 
  @override
  public int div(int i, int j) {
    int result = i / j;
    return result;
  }
 
}
 package com.atguigu.spring.aop;
 
public class arithmeticcalculatorloggingimpl implements arithmeticcalculator {
 
  @override
  public int add(int i, int j) {
    system.out.println("the method add begins with [" + i + "," + j + "]");
    int result = i + j;
    system.out.println("the method add ends with " + result);
    return result;
  }
 
  @override
  public int sub(int i, int j) {
    system.out.println("the method sub begins with [" + i + "," + j + "]");
    int result = i - j;
    system.out.println("the method sub ends with " + result);
    return result;
  }
 
  @override
  public int mul(int i, int j) {
    system.out.println("the method mul begins with [" + i + "," + j + "]");
    int result = i * j;
    system.out.println("the method mul ends with " + result);
    return result;
  }
 
  @override
  public int div(int i, int j) {
    system.out.println("the method div begins with [" + i + "," + j + "]");
    int result = i / j;
    system.out.println("the method div ends with " + result);
    return result;
  }
 
}
  
package com.atguigu.spring.aop;
 
import java.lang.reflect.invocationhandler;
import java.lang.reflect.method;
import java.lang.reflect.proxy;
import java.util.arrays;
 
public class arithmeticcalculatorloggingproxy {
   
  //要代理的对象
  private arithmeticcalculator target;
   
  public arithmeticcalculatorloggingproxy(arithmeticcalculator target) {
    super();
    this.target = target;
  }
 
  //返回代理对象
  public arithmeticcalculator getloggingproxy(){
    arithmeticcalculator proxy = null;
    // 代理对象有哪一个类加载器负责加载
    classloader loader = target.getclass().getclassloader();
    // 代理对象的类型,即其中有哪些方法
    class [] interfaces = new class[]{arithmeticcalculator.class};
    // 当调用代理对象的其中方法时,执行下面的代码
    invocationhandler h = new invocationhandler() {
      /**
       * proxy: 代理对象。 一般不使用该对象
       * method: 正在被调用的方法
       * args: 调用方法传入的参数
       */
      @override
      public object invoke(object proxy, method method, object[] args)
          throws throwable {
        // 在方法内部不会直接调用proxy对象的某个方法,proxy.tostring()会造成死循环调用invoke方法
        string methodname = method.getname();
        //打印日志
        system.out.println("[before] the method " + methodname + " begins with " + arrays.aslist(args));
         
        //调用目标方法
        object result = null;
         
        try {
          //前置通知
          result = method.invoke(target, args);
          //返回通知, 可以访问到方法的返回值
        } catch (nullpointerexception e) {
          e.printstacktrace();
          //异常通知, 可以访问到方法出现的异常
        }
         
        //后置通知. 因为方法可以能会出异常, 所以访问不到方法的返回值
         
        //打印日志
        system.out.println("[after] the method ends with " + result);
         
        return result;
      }
    };
     
    /**
     * loader: 代理对象使用的类加载器。
     * interfaces: 指定代理对象的类型. 即代理代理对象中可以有哪些方法.
     * h: 当具体调用代理对象的方法时, 应该如何进行响应, 实际上就是调用 invocationhandler 的 invoke 方法
     */
    proxy = (arithmeticcalculator) proxy.newproxyinstance(loader, interfaces, h);
     
    return proxy;
  }
}
  

package com.atguigu.spring.aop;
 
import org.springframework.context.applicationcontext;
import org.springframework.context.support.classpathxmlapplicationcontext;
 
public class main {
   
  public static void main(string[] args) {
    // arithmeticcalculator arithmeticcalculator = new arithmeticcalculatorimpl();
    arithmeticcalculator arithmeticcalculator = new arithmeticcalculatorloggingimpl();
     
    arithmeticcalculator = new arithmeticcalculatorloggingproxy(arithmeticcalculator).getloggingproxy();
     
    int result = arithmeticcalculator.add(11, 12);
    system.out.println("result:" + result);
     
    result = arithmeticcalculator.div(21, 3);
    system.out.println("result:" + result);
     
  }
   
}

  示例二、

package com.test.junit;
 
import java.lang.reflect.invocationhandler;
import java.lang.reflect.method;
import java.lang.reflect.proxy;
 
public class proxytest {
 
  public static void main(string[] args) {
    realsubject realsubject = new realsubject();
    myinvocationhandler myinvocationhandler = new myinvocationhandler();
    object object = myinvocationhandler.bind(realsubject);
    subject subject = (subject) object;
    subject.action();
  }
}
// 动态代理的使用
interface subject{
  void action();
}
// 被代理类
class realsubject implements subject{
 
  @override
  public void action() {
 
    system.out.println("我是被代理类,记得执行我哦。。。。");
  }
   
}
 
class myinvocationhandler implements invocationhandler{
 
  object object;// 实现了接口的被代理类的对象的声明
  /**
   * description:①给被代理的对象实例化 ②返回一个代理类对象
   * @param
   * @author xiazhongwei
   * @data 2016年9月29日:下午4:13:43
   * @return
   */
  public object bind(object object){
    this.object = object;
    return proxy.newproxyinstance(object.getclass().getclassloader(), object.getclass().getinterfaces(), this);
  }
  /**
   * 当通过代理类的对象发起对被重写的方法的调用时,都会转化为对如下的invok方法的调用
   */
  @override
  public object invoke(object proxy, method method, object[] args)
      throws throwable {
    object returnobject = method.invoke(object, args);
    return returnobject;
  }
}



感谢阅读此文,希望能帮助到大家,谢谢大家对本站的支持!