反射 动态代理

 之前参与一个项目，使用的技术框架是struts2+ibatis，业余好奇探索了下，于是有幸接触到Java的反射和动态代理。我知道在struts2的拦截器中使用了反射和动态代理，

据说很多经典的框架，比如spring、hibernate、ibatis等也都大范围使用了。这两种技术大概意思如下：

反射：在程序运行的时候，动态的获取某个类中的属性和方法，并且能够调用(很多框架能自动识别你写的类，然后调用一些共同的方法，靠的就是它)。

代理：给类包装上一层壳，通过这个壳去操作这个类，使得你在操作这个类之前之后可以做一些你想做的事情。

反射介绍

反射比较简单，主要使用Class类，Class类提供了运行时获取或调用某个类具体内容的方法。如下代码作实例：

待调用的类MyClass：

public class MyClass {
    private int myInt;
    private String myString;

    public MyClass(){

    }

    public MyClass(int a){
        this.myInt = a;
    }

    public void Method2Void(){

    }

    public int Method2Int(){
        System.out.println("Method2Int has run");
        return 0;
    }

    public String Method2String(){
        return "";
    }

    public Object Method2Object() {
        return new Date();
    }

    public void Method3Param(int a, String b){
        System.out.println("Method3Param has run with param-a:" + a + " and param-b:" + b);
    }
}

Main函数

public static void main(String[] args){
    MyClass myClass = new MyClass();
    Class cls = myClass.getClass();//获取一个类的Class

    System.out.println("1:" + cls.getName());//名字
    System.out.println("2:" + cls.getSimpleName());
    System.out.println("3:" + cls.getPackage());
    try{
        Method m = cls.getMethod("Method2Int", new Class[]{});//获取一个类的方法
        m.invoke(myClass, new Object[]{});//精髓所在，调用这个类的方法

        Method m2 = cls.getMethod("Method3Param", new Class[]{int.class, String.class});
        m2.invoke(myClass, new Object[]{5, "fake"});//调用这个类的方法，带参数的
    }catch(Exception e){
        e.printStackTrace();
    }
    Method[] ms = cls.getMethods();

    for(Method m:ms){
        System.out.println(m.getName());
    }


    try{
        Class cls2 = Class.forName("MyClass");//这种方法也能获取一个类的Class，同时能动态载入这个类
    }catch(Exception e){
        e.printStackTrace();
    }
}

下面详细介绍下代理

      代理这种现象在生活中是非常常见的，比如你要买火车票，可以让你的朋友帮你买，也可以托代售点帮你买。你把钱给了他们，他们可能会做任何事情。也许你朋友忘记；或者代售点把你黑了。当然，程序是你的，你可以控制他们的行为。

      代理有普通代理和动态代理。上面说的你的朋友，可以看成是普通代理，代售点可以看成是动态代理。区别在于，你的朋友并不会帮每个人都买票，仅仅帮他认识少部分人买，而代售点是来者不拒的，具有通用性。

      使用代理模式，需要区分真实对象和代理对象。代理对象中含有真实对象的引用，可以对真实对象进行操作，调用真实对象的方法。可以通过调用代理对象的方法，间接的去调用真实对象的方法。

下面还是举例来说说这两种代理吧。

以下是这两种代理所需的类：

行为PersonAct.java

package proxy;

public interface PersonAct {
    void buyTicket();//买票
    void checkProperty();//查看财产
}

抽象类Person.java

import java.util.Map.Entry;

public abstract class Person implements PersonAct{
    //全部家当放在这个HashMap里
    HashMap<String, Object> property = new HashMap<String, Object>();

    String name;

    public Person(String name, int money){
        this.name= name;
        this.property.put("money", money);
    }

    //打印目前家当
    public void checkProperty(){
        System.out.println(this.name + "的家当如下：");
        Iterator<Entry<String, Object>> iter = property.entrySet().iterator();
        while(iter.hasNext()){
            Entry<String, Object> entry = (Entry<String, Object>)iter.next();
            System.out.println(entry.getKey() + "---" + entry.getValue());
        }
    }
}

真实类Boy.java

package proxy;

public class Boy extends Person{

    public Boy(String name, int money){
        super(name, money);
    }

    //买票
    @Override
    public void buyTicket() {
        int money = (Integer)property.get("money");

        property.put("money", money - 38);//扣钱
        property.put("ticket", "北京到上海机票");//拿票
    }
}

真实类Girl.java

package proxy;

public class Girl extends Person{

    public Girl(String name, int money){
        super(name, money);
    }

    @Override
    public void buyTicket() {
        int money = (Integer)property.get("money");

        property.put("money", money - 46);//扣钱
        property.put("ticket", "北京到深圳机票");//拿票
    }
}

上面的类Boy和Girl代表现实生活中的两个人，Boy自己去买票的过程如下。

Boy boy = new Boy("西门庆", 100);
boy.checkProperty();
boy.buyTicket();
boy.checkProperty();

结果将会打印出boy购票前和投票后的家当。

1，普通代理

类FatherOfBoy.java

package proxy;

public class FatherOfBoy {
    private Boy boy = new Boy("西门庆", 100);

    public void buyTicket(){
        boy.buyTicket();
    }

    public void checkProperty(){
        boy.checkProperty();
    }
}

概念很好理解，普通代理买票可以这样测试。

FatherOfBoy father = new FatherOfBoy();
father.checkProperty();
father.buyTicket();
father.checkProperty();

2，  动态代理

动态代理主要通过继承InvocationHandler接口来实现。

ProxyAgency.java如下：

package proxy;

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;

public class ProxyAgency implements InvocationHandler{
    private Person target;//真实对象的引用

    public void setTarget(Person target) {
        this.target = target;
    }

    public ProxyAgency(){

    }

    public ProxyAgency(Person obj){
        this.setTarget(obj);
    }

    //obj,这个是代理对象
    //method,具体调用的方法
    //args,调用方法的时候传进来的参数，一般都直接传给真实对象即可
    @Override
    public Object invoke(Object obj, Method method, Object[] args) throws Throwable {
        //target,真实对象,收取手续费10元
        if(method.getName().equalsIgnoreCase("buyTicket")){
            int money = Integer.parseInt(target.property.get("money").toString());
            target.property.put("money", money - 10);
        }
        //target,真实对象,下面一句属于java反射机制的东西，用反射机制获取真实对象的方法
        return method.invoke(target, args);//调用真实对象的方法
    }
}

调用实例：

        //代理对象构建器
        ProxyAgency proxyAgency = new ProxyAgency();

        //真实对象
        Boy b = new Boy("西门庆", 100);
        Girl g = new Girl("潘金莲", 200);

        //代理对象,获取方法1
        PersonAct p1 = (PersonAct) Proxy.newProxyInstance(Person.class.getClassLoader(), new Class[]{ PersonAct.class }, proxyAgency);

        //真实对象注入构建器，也可以在构建器的构造函数中注入
        proxyAgency.setTarget(b);


        //代理对象获取方法2
//        Class<?> cls = g.getClass();
//        PersonAct p1 = (PersonAct) Proxy.newProxyInstance(cls.getClassLoader(), cls.getInterfaces(), proxyAgency);

        p1.checkProperty();
        p1.buyTicket();
        p1.checkProperty();

        proxyAgency.setTarget(g);

        p1.checkProperty();
        p1.buyTicket();
        p1.checkProperty();

输出如下：

西门庆的家当如下：
money---100
西门庆的家当如下：
ticket---北京到上海机票
money---52
潘金莲的家当如下：
money---200
潘金莲的家当如下：
ticket---北京到深圳机票
money---144