java反射与代理

反射

类是程序的一部分，每个类都有一个Class对象。换言之,每当编写并编译了一个新类，就会产生一个Class对象(更恰当的来说，是被保存在一个同名的.class文件中)。一旦某个类的Class对象被载入内存，它就用来创建这个类的所有对象。对于反射来说，就是在运行时打开与检查.class文件。

import java.lang.reflect.Method;
/**
 * Created by zhanyunwu on 2017/6/6.
 */
public class ReflectSample {
    public static void main(String args[]){
        try {
            Class<?> c=Class.forName("com.proxy.sample.People");
            People p=(People) c.newInstance();
            Method m=c.getMethod("say",String.class);
            String name=(String)m.invoke(p,"");
            System.out.println(name);
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        } catch (IllegalAccessException e) {
            e.printStackTrace();
        } catch (InstantiationException e) {
            e.printStackTrace();
        } catch (NoSuchMethodException e) {
            e.printStackTrace();
        } catch (InvocationTargetException e) {
            e.printStackTrace();
        }
    }
}
class People{
    private String name="default";
    public String say(String name){
        if("".equals(name))
            return this.name;
        return name;
    }
}

静态代理

静态代理在编译期就决定了被代理对象。

//公共接口
public interface CommonService {
    void play();
}
//实现类
public class ComServiceImpl implements CommonService{
    @Override
    public void play() {
        System.out.println("comServiceImpl");
    }
}
//代理类，添加自己额外的功能
public class ProxySubject implements CommonService{
    private CommonService commonService;//被代理对象
    public ProxySubject(CommonService cs){
        this.commonService=cs;
    }
    @Override
    public void play() {
        System.out.println("start.........."+System.currentTimeMillis());
        commonService.play();
        System.out.println("end..........."+System.currentTimeMillis());
    }
}

动态代理

动态代理,通过反射在运行时动态的生成代理类。这是使用java提供的Proxy.newProxyInstance与InvocationHandler实现。背后具体的实现细节可参考,启发很大。前者生成代理类，后者可以在其中添加额外的功能

  //公共接口
  public interface CommonService {
    void play();
}
//代理类
public class ProxyHandler {
    public static Object getProxyObject(final Object c){
        return Proxy.newProxyInstance(c.getClass().getClassLoader(), c.getClass().getInterfaces(), new InvocationHandler() {
            @Override
            public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
                System.out.println("开始事务..........");
                Object obj=method.invoke(c,args);
                System.out.println("结束事务..........");
                return obj;
            }
        });
    }
}
//测试
 public static void main(String args[]){
        CommonService cs=new ComServiceImpl();
        CommonService proxy= (CommonService) ProxyHandler.getProxyObject(cs);
        proxy.play();
    }