Spring学习之代理

                                     Spring的核心就是IOC和AOP

        IOC就是控制反转:   就是用配置文件的方式给javabean 赋值.

             正常的在程序里;用new 的方式创建一个对象的时候,他就固定了值,

             如果是注入的方式的话可以根据配置文件的配置给他一个值(就变成可改的了).这个好像进一步模式化了程序代码.(个人理解)总有一天可能

            一个程序完成所有的应用吧.只要我改配置文件.

      AOP:面向切面编程:个人理解就是在执行方法的时候做一些事情.让业务更纯净一些,其他的一些必须的功能就切入一段代码完成.如事物.

      而AOP的底层是用代理模式完成的.所以代理模式的理解有助于理解AOP

      一.静态代理:  

            java的代理需要接口:

          所以先定义一个接口:

                TestInterface

  

package po;

public interface TestInterface {
    String getConten();
}

实现类:

package po.impl;


public class TestImpl implements Student {

    @Override
    public String getConten() {
        
        return "我是真实对象";
    }

}

静态代理类:

package po.impl;


public class TestProxy implements TestInterface{
    private TestInterface test;
    
    
    public TestProxy() {
        
    }

    public TestProxy(TestInterface test) {
        
        this.test = test;
    }

    @Override
    public String getConten() {
        
        System.out.println("我是增强"); 
        System.out.println(test.getConten());
        return null;
    }

}

测试类:

  

public class MYtest {
  public  static void main(String[] args) {
      //测试

      new TestProxy(new TestImpl()).getConten();

  }

}
      

动态代理:  那个接口和实现类不变,不用创建代理类了,java会自动创建代理类

     测试类代码如下

package ui;

import java.lang.reflect.Method;

import org.springframework.cglib.proxy.InvocationHandler;
import org.springframework.cglib.proxy.Proxy;

import po.TestImpl;
import po.TestInterface;
import po.TestInterface;
import po.TestInterface;
import po.TestProxy;

public class MYtest {
  public  static void main(String[] args) {
    
      //测试
      new TestProxy(new TestImpl()).getConten();
     //测试动态代理
      final TestInterface stu=new TestImpl();
      TestInterface proxy = (TestInterface)Proxy.newProxyInstance(stu.getClass().getClassLoader(),stu.getClass().getInterfaces(),new InvocationHandler() {
        @Override
        public Object invoke(Object proxy, Method method, Object[] h)
                throws Throwable {
             System.out.println("我是动态代理增强!!!");
             return method.invoke(stu,h);
        }
    });
     System.out.println( proxy.getConten());;
      
  }
}

       其中调用了Proxy类的newInstance()方法该方法的参数有三个

           1.ClassLoader  :类加载器,new的时候就是这个创建的类,对象.getClass().getClassLoader()的得到改对象的类的类加载器,

           2.Class[]   得到接口数组

           3.InvocationHandler :句柄(我不太懂,就是一个匿名类,就是程序创建的动态代理类,我是这么理解的.)

 其中这部分invoke方法就是执行的动态代理的方法,他的三个参数

1.proxy:  指代我们所代理的那个真实对象
2.method:　　指代的是我们所要调用真实对象的某个方法的Method对象
3.args:　　指代的是调用真实对象某个方法时接受的参数

@Override
        public Object invoke(Object proxy, Method method, Object[] h)
                throws Throwable {
             System.out.println("我是动态代理增强!!!");
             return method.invoke(stu,h);
        }