java（代理和反射）

反射和代理

反射

Class类和java.lang.reflect包

• 获取Class对象
  jdk提供了三种方式获取一个对象的Class，就User user来说

1. user.getClass()，这个是Object类里面的方法

2. User.Class属性，任何的数据类型，基本数据类型或者抽象数据类型，都可以通过这种方式获取类

3. Class.forName("")，Class类提供了这样一个方法，让我们通过类名来获取到对象类
   这三种方法用的最多的就是第三种，那么获取到类之后，Class类提供了很多获取类属性，方法，构造方法的api

//获取整个类  
            Class c = Class.forName("java.lang.Integer");  
              //获取所有的属性?  
            Field[] fs = c.getDeclaredFields();  
       
                   //定义可变长的字符串，用来存储属性  
            StringBuffer sb = new StringBuffer();  
            //通过追加的方法，将每个属性拼接到此字符串中  
            //最外边的public定义  
            sb.append(Modifier.toString(c.getModifiers()) + " class " + c.getSimpleName() +"{\n");  
            //里边的每一个属性  
            for(Field field:fs){  
                sb.append("\t");//空格  
                sb.append(Modifier.toString(field.getModifiers())+" ");//获得属性的修饰符，例如public，static等等  
                sb.append(field.getType().getSimpleName() + " ");//属性的类型的名字  
                sb.append(field.getName()+";\n");//属性的名字+回车  
            }  
      
            sb.append("}");  
      
            System.out.println(sb);

//获取类  
    Class c = Class.forName("User");  
    //获取id属性  
    Field idF = c.getDeclaredField("id");  
    //实例化这个类赋给o  
    Object o = c.newInstance();  
    //打破封装  
    idF.setAccessible(true); //使用反射机制可以打破封装性，导致了java对象的属性不安全。  
    //给o对象的id属性赋值"110"  
    idF.set(o, "110"); //set  
    //get  
    System.out.println(idF.get(o));

getDeclaredMethods()    获取所有的方法

getReturnType()    获得方法的返回类型

getParameterTypes()    获得方法的传入参数类型

getDeclaredMethod("方法名",参数类型.class,……)    获得特定的方法

getDeclaredConstructors()    获取所有的构造方法

getDeclaredConstructor(参数类型.class,……)    获取特定的构造方法

getSuperclass()    获取某类的父类

getInterfaces()    获取某类实现的接口

代理

代理模式是常用的Java设计模式，它的特征是代理类与委托类有同样的接口，代理类主要负责为委托类预处理消息、过滤消息、把消息转发给委托类，以及事后处理消息等。代理类与委托类之间通常会存在关联关系，一个代理类的对象与一个委托类的对象关联，代理类的对象本身并不真正实现服务，而是通过调用委托类的对象的相关方法，来提供特定的服务。按照代理的创建时期，代理类可以分为2种。
静态代理：由程序员创建或特定工具自动生成源代码，再对其编译。在程序运行前，代理类的.class文件就已经存在了。
动态代理：在程序运行时，由Java反射机制动态生成字节码。分为jdk动态代理和CGLIB动态代理

• 静态代理

public interface Count { 
    public void queryCount();
}
public class CountImpl implements Count {
    public void queryCount() { 
        System.out.println("查看账户方法...");
    }
}
//代理类
public class CountProxy implements Count { 
    private CountImpl countImpl;   
    public CountProxy(CountImpl countImpl) { 
        this.countImpl = countImpl; 
    }   
    @Override 
    public void queryCount() { 
        System.out.println("事务处理之前");           
        countImpl.queryCount(); // 调用委托类的方法;
        System.out.println("事务处理之后"); 
    }
｝ 
//测试类
public class TestCount { 
    public static void main(String[] args) { 
        CountImpl countImpl = new CountImpl(); 
        CountProxy countProxy = new CountProxy(countImpl); 
        countProxy.queryCount();   
    } 
｝

• jdk动态代理（Proxy和InvocationHandler ）

interface Subject {
    public String say(String name, int age);
}
class RealSubject implements Subject {
    @Override
    public String say(String name, int age) {
        return name + "  " + age;
    }
}
//JDK动态代理类
class MyInvocationHandler implements InvocationHandler {
    private Object target = null;
    //绑定委托对象并返回一个代理类
    public Object bind(Object target) {
        this. target = target;
        return Proxy.newProxyInstance(target.getClass().getClassLoader(),
　　　　　　　　　　target.getClass().getInterfaces(), this); //要绑定接口（cglib弥补了这一点）
    }
    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        System.out.println(“before method!”);
        Object temp = method.invoke(target, args);
        System.out.println(“after method!”);
        return temp;
    }
}
class hello {
    public static void main(String[] args) {
        MyInvocationHandler demo = new MyInvocationHandler();
        Subject sub = (Subject) demo.bind(new RealSubject());
        String info = sub.say("Rollen", 20);
        System.out.println(info);
    }
}

• CGLIB动态代理（MethodInterceptor和Enhancer ）

public interface BookFacade { 
    public void addBook(); 
} 
public class BookFacadeImpl1 { 
    public void addBook() { 
        System.out.println("增加图书的普通方法..."); 
    } 
} 
 
import java.lang.reflect.Method;   
import net.sf.cglib.proxy.Enhancer; 
import net.sf.cglib.proxy.MethodInterceptor; 
import net.sf.cglib.proxy.MethodProxy; 
//cglib动态代理类
public class BookFacadeCglib implements MethodInterceptor { 
    private Object target;    
    //绑定委托对象并返回一个代理类
    public Object getInstance(Object target) { 
        this.target = target; 
        Enhancer enhancer = new Enhancer(); 
        enhancer.setSuperclass(this.target.getClass()); 
        // 回调方法 
        enhancer.setCallback(this); 
        // 创建代理对象 
        return enhancer.create(); 
    }    
    @Override 
    // 回调方法 
    public Object intercept(Object obj, Method method, Object[] args, 
            MethodProxy proxy) throws Throwable { 
        System.out.println("事物开始"); 
        Object temp = proxy.invokeSuper(obj, args); 
        System.out.println("事物结束"); 
        return temp;   
    } 
} 
public class TestCglib {
    public static void main(String[] args) { 
        BookFacadeCglib cglib = new BookFacadeCglib(); 
        BookFacadeImpl1 bookCglib = (BookFacadeImpl1)cglib.getInstance(new BookFacadeImpl1()); 
        bookCglib.addBook(); 
    } 
}