java反射技术

学过struts2的人都知道，这个框架中定义了很多拦截器，主要作用是在执行某个action前先过滤某些行为，当符合条件时才执行action中的方法。当然这也涉及到了另一种编程思想(AOP面向切面编程)。本文主要讲一下这里面的大致实现方式。其实它的实现模式分两种即代理模式和反射机制。代理模式又可分为静态代理和动态代理，而动态代理又是基于反射机制的。因为我先从代理问题开始讨论，由此引出反射机制问题。
什么是代理，在我看来，其实就是某个问题某个事物不能解决，交给另一个事物来完成，从而达到相同的效果。比如你不能解决的问题，那可以交给其他人来完成。代理也就大概这个意思。在java中，通过代理可以将某些与业务逻辑无关的通用操作分离出来单独执行。下面我以“记录删除操作的日志”为例，简要阐述一下java中的代理。
首先我们先来看一下，如果将删除和记录日志写到一起，我们可以得到下面这样的代码。

package com.ev.testdelete;

import java.util.logging.Level;
import java.util.logging.Logger;

public class TestDelete {
    Logger log = Logger.getLogger(this.getClass().getName());
    public void delete(){
        log.log(Level.INFO, "删除之前");
        System.out.println("delete");
        log.log(Level.INFO, "删除之后");
    }
}

在主方法中我们执行这个方法可以得到下面的结果

import com.ev.testdelete.TestDelete;

public class Test {
    public static void main(String[] arg){
        TestDelete testDelete = new TestDelete();
        testDelete.delete();
    }
}

我们可以发现，这种方式是将业务逻辑（删除操作）与记录日志是合在一起的。这将导致，如果整个项目大起来的时候，维护起来是很困难的。因此就很有必要将这两个操作分开，第一个方法我们可以使用静态代理的方式。这种方式中我们要将代理类和被代理类实现同一个接口。
这个接口如下：

package com.ev.dao;

public interface DeleteDao {
    public void delete();
}

下面是被代理类:

package com.ev.testdelete;
import com.ev.dao.DeleteDao;

public class TestDelete implements DeleteDao{   
    public void delete(){       
        System.out.println("delete");       
    }
}

然后我们再创建一个代理类如下：

package com.ev.testdelete;

import java.util.logging.Level;
import java.util.logging.Logger;

import com.ev.dao.DeleteDao;

public class DeleteProxy implements DeleteDao {
    Logger log = Logger.getLogger(this.getClass().getName());
    DeleteDao dao;
    //将代理类与代理类绑定在一起
    public DeleteProxy(DeleteDao dao){
        this.dao = dao;
    }
    public DeleteProxy(){

    }
    //在这里记录日志，但业务逻辑还是由被代理类中的方法实现
    @Override
    public void delete() {
        log.log(Level.INFO, "删除之前");
        dao.delete();//执行被代理类中的业务逻辑
        log.log(Level.INFO, "删除之后");

    }

}

在主方法中我们可以这样调用。

package com.ev.proxyhanddle;

import java.lang.reflect.Method;

import com.ev.dao.DeleteDao;
import com.ev.person.Person;
import com.ev.testdelete.DeleteProxy;
import com.ev.testdelete.TestDelete;

public class Test {
    public static void main(String[] arg){

        DeleteDao dao = new DeleteProxy(new TestDelete());
        dao.delete();
    }
}

得到的结果与之前的一样。但是这种方式已经将日志记录与业务逻辑分开了。但是静态代理有个缺点，就是它只能代理相同类结构的对象，也就是说，这个代理类只能代理实现这个接口的类的对象，如果有一个类实现了另外一个接口，那么这个代理类就不能生效了。这就涉及到了动态代理，其实在动态代理中就用到了反射机制。它可以使用方法动态调用。
动态代理定义如下：

package com.ev.proxyhanddle;

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
import java.util.logging.Level;
import java.util.logging.Logger;


public class MyProxy implements InvocationHandler {
    private Logger log = Logger.getLogger(this.getClass().getName());
    private Object delegate; 
    //将代理类与代理类绑定在一起
    public Object bind(Object delegate){
        this.delegate = delegate;
        return Proxy.newProxyInstance(delegate.getClass().getClassLoader(), delegate.getClass().getInterfaces(), this);
    }
    //在这里记录日志，但业务逻辑还是由被代理类中的方法实现
    @Override
    public Object invoke(Object arg0, Method method, Object[] arg2) throws Throwable {//这个方法会自动调用

        log.log(Level.INFO, "删除之前 ");       
        log.log(Level.INFO, "删除之后 ");
        //执行被代理类中的业务逻辑
        return method.invoke(delegate, arg2);//这是返回被代理类中相关方法的返回值
    }
}

这时dao接口可以定义如下：

package com.ev.dao;

public interface UserDao {
    public String delete(String name);
}

它的实现类为：

package com.ev.daoimp;

import com.ev.dao.UserDao;

public class UserDaoImp implements UserDao {

    @Override
    public String delete(String name) {     
        System.out.println(name+"删除成功！");
        return "success!";
    }

}

主方法调用如下：

package com.ev.proxy;

import com.ev.dao.UserDao;
import com.ev.daoimp.UserDaoImp;
import com.ev.proxyhanddle.MyProxy;

public class TestProxy {
    public static void main(String[] args){
        UserDao user = (UserDao)new MyProxy().bind(new UserDaoImp());
        String info = user.delete("YKG");
        System.out.println(info);
    }
}

下图是执行结果

这时不管你的类是实现哪个接口，都可以用这个代理类进行代理了。
最后我们要知道的是，这个动态代理其实就是用到了java中的反射机制。最基本的就是Class.forName()这个函数。这个函数会返回某个类的自描述类，当然自描述类也是一种类，这个类包含了被“描述类”的相关信息，比例，这个类有哪些方法，有哪些成员变量，哪些构造方法，哪些是公有的，哪些是私有的等等。
例如，我们创建一个Person类。

package com.ev.person;

public class Person {
    private int age;
    private String name;
    public int getAge() {
        return age;
    }
    public void setAge(int age) {
        this.age = age;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
}

这个类包含姓名和年龄。
然后我们可以通过Class cls = Class.forName("com.ev.person.Person");获得这个类的信息。Person per = (Person)cls.newInstance();得到这个类的实例。我们也可以获得这个类的方法然后动态调用。具体如下 ：

package com.ev.proxyhanddle;

import java.lang.reflect.Method;

import com.ev.dao.DeleteDao;
import com.ev.person.Person;
import com.ev.testdelete.DeleteProxy;
import com.ev.testdelete.TestDelete;

public class Test {
    public static void main(String[] arg){
        try {
            //得到Person类的自描述类
            Class cls = Class.forName("com.ev.person.Person");
            //得到Person类的实例
            Person per = (Person)cls.newInstance();
            //动态获得Person类的setName方法
            Method setMethod = cls.getMethod("setName", String.class);
           //动态调用setName方法
            setMethod.invoke(per, "YKG");
            //获得getName方法
            Method getMethod = cls.getMethod("getName", null);
            //动态调用getName方法
            String name = (String)getMethod.invoke(per, null);
            System.out.println(name);
        } catch (Exception e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
    }
}

所以不管是struts2的拦截器还是动态代理，其底层还是用到了反射技术。struts2的拦截器只是通过底层的反射技术，获得某个action从而动态执行其中的方法。