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("大家好，我是"+
3fe8
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();
}
}