Java中反射、静态代理、动态代理

反射：
关键在于动态，预编译时并不进行而当运行时需要调用某个对象、方法、类等时利用该反射机制进行，该机制可获得任何类的内部信息、对象、属性和方法、
 *运行时，判断任何一个对象所属的类，创造任意类的对象。获取并调用其方法、属性、

getMethod/getfield:只能获取public修饰的方法和属性
getDeclaredField/getDeclaredMetod:能获取所有修饰权限的属性和方法

重点内容：
理解class类并实例化Class类对象
运行时创建类对象和获取类的完整结构
通过反射调用制定方法和属性
动态代理


反射方式：
*1. 类名.class;
*2. 对象.getclass//通过运行时类对象，调用getclass方法，返回其运行时类
*3. Class.forname("包名--类名")
*4. ClassLoader:类加载器，用来把类装入内存，包括两类：启动类加载器（bootStrap）和用户自定义加载器.
   ClassLoader classLoader = this.getClass().getClassLoader();
    Class clazz =classLoader(类名);

newInstance使用：
 前提条件：有无参构造器并具有权限--Object object = clazz.newInstance();

使用反射获取类的完整结构：
1.获取属性field，在通过属性field获取其权限修饰符和类型
2.获取Method，权限，注释，父类方法，接口方法，
3.获取构造器，包括父类的
4.调用获取的方法和属性，[private modify--setAccessible(true)]
 *field.set（obj,param）;
 *method.invoke(obj,param)

Java中静态代理与动态代理

为什么要用代理：

代理模式的作用是：为其他对象提供一种代理以控制对这个对象的访问。在某些情况下，一个客户不想或者不能直接引用另一个对象，而代理对象可以在客户端和目标对象之间起到中介的作用。 

代理模式一般涉及到的角色有： 

抽象角色：声明真实对象和代理对象的共同接口； 

代理角色：代理对象角色内部含有对真实对象的引用，从而可以操作真实对象，同时代理对象提供与真实对象相同的接口以便在任何时刻都能代替真实对象。同时，代理对象可以在执行真实对象操作时，附加其他的操作，相当于对真实对象进行封装。 

<span style="background-color: rgb(51, 102, 255);"> * 静态代理</span>

/*代理三要素：接口，实现接口的代理类和被代理类
 **/
//*******interface
  interface Book{
	 
	 public void productBook();
 }

//*****实现接口的被代理类
  class BioBook implements Book{
      
	  
	@Override
	public void productBook() {
		System.out.println("学了生物，穷途末路");
	}
	  
  }

//******实现接口的代理类
  class ProxyBook implements Book{
     Book book;
     
     //将被代理类对象引入到代理类
	public ProxyBook(Book book) {
		super();
		this.book = book;
	}

	@Override
	public void productBook() {
		System.out.println("我是代理，只管制书");
		//被代理方法通过被代理对象进行调用
		book.productBook();
	}
	 
  }

  //*********测试程序
   public class StaticProxyTest{
	   
	public static void main(String[] args){
		BioBook bb=new BioBook();//获取被代理对象
		ProxyBook pb=new ProxyBook(bb);//传入代理类
		pb.productBook();//在代理类里面进行生产
	}   
   }

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
<span style="background-color: rgb(102, 102, 204);">
动态代理</span>
/*Java代理的三要素：接口,实现接口的被代理类，实现接口的代理类
 * **/
//*******interface
  interface Book{
     
     public void productBook();
 }

//*****实现接口的被代理类
  class BioBook implements Book{

    @Override
    public void productBook() {
        System.out.println("学了生物，穷途末路");
    }
      
  }
  
 //******动态代理类
class MyInvolcationHandler implements InvocationHandler{
    Object obj ;
    
    //将被代理类对象引入代理类
    public Object replaceObj(Object obj){
        this.obj= obj;
        return Proxy.newProxyInstance(this.getClass().getClassLoader(),obj.getClass().getInterfaces(),this);
    }
    //当通过代理类对象对重写方法进行调用时，都会自动转换为对如下invoke（）方法调用
    @Override
    public Object invoke(Object proxy, Method method, Object[] args)
            throws Throwable {
        System.out.println("调用了invoke方法");
        //method()返回值是returnvalue
      Object returnValue= method.invoke(obj, args);
     return returnValue;
    }
    
}



public class DynamicProxyTest {
    public static void main(String[] args){
        BioBook bb=new BioBook();//获取被代理对象
        MyInvolcationHandler myh=new MyInvolcationHandler();
        Object obj = myh.replaceObj(bb);
        Book book =(Book) obj;//已知obj为Book类型，可以强转，否则无法调用方法
        book.productBook();
        
    }   
}