spring源码阅读（1）

spring核心是IOC和AOP，AOP的底层是代理实现。

代理分为两种：jdk动态代理和cglib代理

区别：

动态代理：被代理对象是要实现一个接口，代理类首先要拿到这个接口，来进行强制转换，通过反射来生成代理对象

public class MeiPo implements InvocationHandler{

        // 这个是被代理对象实现的接口
	private Person person;
	
	// 获取被代理对象的资料
	public Object getInstance(Person person){
		this.person = person;
		Class clazz = person.getClass();
		Object newProxyInstance = Proxy.newProxyInstance(clazz.getClassLoader(), clazz.getInterfaces(), this);
		
		// 返回被代理对象
		return newProxyInstance;
	}
	
	@Override
	public Object invoke(Object proxy, Method method, Object[] args)throws Throwable {
		System.out.println("增强前");
		//person.findLove();
		method.invoke(this.person, args);
		System.out.println("增强后");
		return null;
	}

}

public class Test {

	public static void main(String[] args) {
		MeiPo meiPo = new MeiPo();
		Person person = (Person) meiPo.getInstance(new Man());
		person.findLove();
	}
	// 动态的代理的原理：
	// 1：拿到被代理对象的引用，然后获取他的接口
	// 2：jdk重新生成一个类，同时实现被代理对象锁实现的接口
	// 3：拿到被代理对象的引用
	// 4：重新生成一个class字节码对象
	// 5：编译
	
	
	// 代理模式必要条件：
	// 两个对象：执行者和被代理对象
	// 执行者要拿到被代理对象引用
}

cglib代理：cglib代理是生成一个被代理对象的子类，来重写父类的方法（被代理对象），然后引用赋值给父类

public class MeiPo2 implements MethodInterceptor{

	public Object getInstance(Man2 man){
		Enhancer enhancer = new Enhancer();
		// 设置被代理对象为父类
		enhancer.setSuperclass(man.getClass());
		enhancer.setCallback(this);
		return enhancer.create();
	}
	@Override
	public Object intercept(Object arg0, Method arg1, Object[] arg2,MethodProxy arg3) throws Throwable {
		
		arg3.invokeSuper(arg0, arg2);
		return null;
	}

}

public class Test2 {

	// jdk代理：是通过接口来进行强制转换的，生成以后的代理对象，可以强制转换为接口
	
	// cglib代理:cglib的动态代理是通过生成一个被代理对象的子类，然后重写父类的方法
	// 生成以后的对象实际是被代理对象的子类，然后子类引用赋值给父类

	// spring AOP思想就是代理模式的具体体现
	
	public static void main(String[] args) {
		MeiPo2 meiPo2 = new MeiPo2();
                // man2是被代理对象，代理对象是man2的子类实现
		Man2 instance = (Man2) meiPo2.getInstance(new Man2());
		instance.findLove();
	}
}

好了，简单记录下~~

spring源码阅读（1）

猜你喜欢