Spring核心原理AOP

框架核心知识-反射，动态代理
1、动态语言，具备反射机制
a、运行时，判断任意一个对象所属类
b、构造任意一个类的对象实例
c、判断任意类所具备的成员变量和方法
d、调用任意类所具备的成员变量和方法
e、生成动态代理

2、java反射中，最核心的api：
java.lang.Class 代表一个类
java.lang.reflect.Method 代表类的方法
java.lang.reflect.Filed 代表类的成员变量
java.lang.reflect.Constructor 代表类的构造方法

3、Class类
正常：import导入-》通过new实例化-》取得实例化对象
反射：实例化对象-》getClass方法-》类的名称
类它既能够拿到属性方法和构造器
例子：

public class Person{
    private String name;
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
}

import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;

public class aop {

    public static void main(String[] args) throws IllegalAccessException, IllegalArgumentException, InvocationTargetException {
        Object obj=new Person();
        Class clazz=obj.getClass();
        System.out.println(clazz.getName()+"----"+clazz.getSimpleName());

        try {
            Method mSet = clazz.getMethod("setName",String.class);
            try {
                mSet.invoke(obj,"12345");
            } catch (IllegalAccessException e) {
                e.printStackTrace();
            } catch (IllegalArgumentException e) {
                e.printStackTrace();
            } catch (InvocationTargetException e) {
                e.printStackTrace();
            }
            Method mGet = clazz.getMethod("getName");
            System.out.println(mGet.invoke(obj));
        } catch (NoSuchMethodException e) {
            e.printStackTrace();
        } catch (SecurityException e) {
            e.printStackTrace();
        }
    }
}

Class的实例获取方式
1、类名.class
2、对象实例.getClass();
3、Class.forName()
4、classLoader.loadClass(“”)

类的加载过程

AOP Spring jdk (反射结合proxy)
动态代理，是指客户通过代理类调用其他对象的方法，并且在程序运行时根据需要动态的创建目标类的代理对象。

package aop;
public interface Person {
    public void sayHello();
}

package aop;

public class Student implements Person{
    private String name="jkxqj";
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    @Override
    public void sayHello() {
        System.out.println("大家好，我是"+name);
    }
}

package aop;

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
public class ProxyHandler implements InvocationHandler{
    private Object obj;
    public ProxyHandler(Object obj){
        this.obj=obj;
    }
    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        System.out.println("调用前。。。");
        Object result = method.invoke(this.obj, args);
        System.out.println("调用后。。。");
        return result;
    }

}

package aop;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Proxy;
public class aop {
    public static void main(String[] args) {
        Person person=new Student();
        InvocationHandler handler=new ProxyHandler(person);
        Person p =(Person)Proxy.newProxyInstance(person.getClass().getClassLoader(),person.getClass().getInterfaces(), handler);
        p.sayHello();
    }
}