动态代理/spring IOC/JAVA反射机制

动态代理
代理的作用就是控制对象的访问权限；

首先我们需要写一个接口 这个就是代理接口

public interface Student {
public  void S1(); 
}

然后在写一个接口的实现类 这个是原类

public class StudentImpl implements Student {
	private String name;

	public StudentImpl() {
	};

	public StudentImpl(String name) {
		this.name = name;
	};

	public String getName() {
		return name;
	}

	public void setName(String name) {
		this.name = name;
	}

	public void holler() {
		System.out.println("holler ");
	}

	public void S1() {
		this.holler();
		System.out.println("我是S1");
	}
}

我们还需要写一个生成代理对象的工厂

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


public class ProxyFactory implements InvocationHandler {
	private Object object = null;

	public Object getp(Object object) {
		this.object = object;
		return Proxy.newProxyInstance(
				this.object.getClass().getClassLoader(),
				this.object.getClass().getInterfaces(),
				this);
	}

	public Object invoke(Object proxy, Method method, Object[] args)
			throws Throwable {
		StudentImpl si = (StudentImpl) this.object;
		Object o = null;
		if (si.getName() != null) {
			o = method.invoke(this.object, args);
			StudentImpl ss = (StudentImpl)o;
			System.out.println(ss.getName());
		}else{
			System.out.println("你的权限不足。");
		}
		
		return o;
	}
}

在这个工厂里面调用 proxy 的构造方法 newProxyInstance 传入相关参数 会返回一个对应的代理对象

我们可以看一下里面的源码

public static Object newProxyInstance(ClassLoader loader,
  				  Class<?>[] interfaces,
  				  InvocationHandler h)
  throws IllegalArgumentException
  {
  if (h == null) {
      throw new NullPointerException();
  }
      Class<?> cl = getProxyClass0(loader, interfaces); 
  try {
          final Constructor<?> cons = cl.getConstructor(constructorParams);
          final InvocationHandler ih = h;
          SecurityManager sm = System.getSecurityManager();
          if (sm != null && ProxyAccessHelper.needsNewInstanceCheck(cl)) {
              return AccessController.doPrivileged(new PrivilegedAction<Object>() {
                  public Object run() {
                      return newInstance(cons, ih);
                  }
              });
          } else {
              return newInstance(cons, ih);
          }
  } catch (NoSuchMethodException e) {
      throw new InternalError(e.toString());
  } 
  }

在这个方法返回的时候又调用了 newInstance，显然这个方法是做创建代理对象的

最后在写一个代理的测试类

package proxytest;

import java.lang.reflect.Proxy;

public class Test {

	public static void main(String[] args) {
		Student student = new StudentImpl("ss");
		ProxyFactory pt = new ProxyFactory();
	    Student  pro = (StudentImpl)pt.getp(student);
	    pro.S1();
	}
}

输出结果：
holler
我是S1

总结

动态代理是在静态代理的基础上进行优化和补充，实现的步骤为
1.编写一个代理接口
2.编写一个接口实现类
3.编写一个代理的的创建工厂
4.测试类。调用工厂传入需要代理的对象

动态代理是在程序员需要时，程序会根据jdk的反射机制对需要的代理类进行加载， 这是动态代理的最大特点，虽然
这点在小程序里面的不到体现，但是在加载大文件时，差异就很明显了， 动态代理中利用了java中的 proxy 类
这是一个创建代理对象的类，上面我们用到了他的构造方法，其内部就是对代理类的加载 预编译的实现过程；
静态代理模式会在程序运行之前，先把代理对象编译成class文件，这是静态代理和动态代理的根本区别
在spring中就有代理这个功能，其实现原理也是相同的，spring中在对象上加上注解或重写其set方法就可以了；
（篇外话）
我们常用的spring框架中的 DI （依赖注入）的实现原理就是跟以上类似。

spring IOC/DI
我们来延伸一下上面的内容，既然说到spring，那么大家对spring 的核心想必都不陌生了吧，没错，它们就是AOP（面向切面编程） 和 IOC（控制反转）， 那我们主要讲讲IOC。
IOC 全称 （Inversion of Control） ，中文叫 “控制反转”，那我们怎么来理解这个控制反转呢？ 首先我们需要知道 IOC的定义是什么，这样我们才能快速的去理解他， IOC 定义: 就是由 Spring IOC 容器来负责对象的生命周期和对象之间的关系。 我们可以大概理解成 IOC就是一个用来创建依赖关系的工具， 为什么不是我们自己来创建这个依赖关系呢，听我娓娓道来， 现在的项目结构一般都是以MVC模式来搭建的，这样代码的规范和维护性就比较高了，当业务逻辑层需要用到其他服务（方法）时，我们通常需要先NEW出这个对象，在用对象调用我们需要的服务，看上去这样很简单，但是仔细想想，我们每次都需要亲力亲为，如果业务复杂度高的话，就算马云也会力不从心吧，并且new出来的这些对象也不好管理，就好像一个没有分类的菜市场，杂七杂八的东西到处都是，对于开发来讲，这样的结果肯定不是我们想见到的，所以我们把这个繁琐的过程就交给spring来处理，简单来讲 IOC 就是一个提供对象依赖的服务，我们来举一个例子：
在没有淘宝之前，我们买东西都需要去商店百货自己找，找完需要的东西之后还要付款，之后还要自己带回家，可能在超市里面有些需要的东西已经卖完了，这样白跑一趟，效率低还费心费力，
有淘宝之后，我们可以直接在手机或者电脑上选购，选购之后直接送货到家 ，免去了中间的一些繁杂的过程，这样我们还能把这个时间省下来，去做更多的事情。
总结：
1.IOC是什么？ IOC是处理对象依赖关系的一种技术，
2. 为什么需要IOC? 原始的方式效率太低。
3. IOC的处理流程：其底层原理用的就是动态代理。

IOC 大致分为三种方式：
1.对象的 getter/setter，首先私有化其对象，在构建对象的无参构造方法
private A a；
public viod setA（A a）{
this.a = a
}

2.构造器注入
A(A a){
this.a = a;
}

3.注解注入，注解是spring 自带的，私有化对象后，在对象前面加上对应的注解，就可以用其对象的服务了。
@Autowired
private RealNameDao realNameDao;