JDK动态代理与spring中的AOP

public Object invoke(Object proxy, Method method, Object[] args) throws Throwable;

public static Object newProxyInstance(ClassLoader loader, Class<?>[] interfaces,InvocationHandler invocationHandler throws IllegalArgumentException

package com.iip;  
 
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;

interface People{
	public  void say();
	public  void run();
}


class Student implements People{ 		//真实的实现类

	public Student(){		
	}	
	
	@Override
	public void say() {
		//check()；	
		System.out.println("-----say-----");
	}	
	

	@Override
	public void run() {
		//check()；		
		System.out.println("-----run-----");
	}
	
	/*
	public void check(){        				 //安全性检查
		System.out.println("-----check-----");   //判断是否是people
	}	
	*/
}	



class myInvocationgHandler implements InvocationHandler{		//使用动态代理
	
	private Object obj;
			
	public Object getProxy(Object obj){								//绑定真实主题类		
		this.obj = obj;	 
		return java.lang.reflect.Proxy.newProxyInstance(			//取得代理对象
								obj.getClass().getClassLoader(),    //生成代理类的字节码加载器
								obj.getClass().getInterfaces(),     //需要代理的接口，被代理类实现的多个接口都必须在这里定义
								this);								
	}
	
	@Override
	public Object invoke(Object proxy, Method method, Object[] args) //动态调用方法
			throws Throwable {
		check();
		System.out.println("代理类名    ： "+ proxy.getClass().getName());
		System.out.println("调用方法名： "+ method.getName());	
		
		Object object = method.invoke(this.obj, args);
		return object;
	}

	public void check(){        				 //安全性检查
		System.out.println("-----check-----");   //判断是否是people
	}
	
}

public class Proxy {

	public static void main(String[] args ){
		
		People student = new Student();	
		
		myInvocationgHandler p =  new myInvocationgHandler(); //绑定到动态代理中
		
		People proxy = (People)p.getProxy(student);
		
		proxy.say();
		proxy.run();		
	}
	
}

	代理类名    ： com.iip.$Proxy0
	调用方法名： say
	-----say-----
	代理类名    ： com.iip.$Proxy0
	调用方法名： run
	-----run-----

import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Before;
import org.aspectj.lang.annotation.Pointcut;


/**
 * 定义Aspect 切面类
 * @author mayday
 *
 */

@Aspect 
public class MyInvocationgHandler {		
	
	/**
	 * 定义Pointcut,Pointcut的名称就是method，此方法不能有返回值和参数，同时该方法也不会执行
	 * 该方法只是一个标识
	 * Pointcut的内容是一个表达式，描述那些对象的那些方法（订阅Joinpoint，即设置哪个函数起作用）
	 */
	@Pointcut("execution(* say*(..)) || execution(* run*(..))")
	private void method(){
		
		System.out.println("-----method-----");  //该函数将不会执行，method方法只是一个标识
	}
	
	/**
	 * 定义Advice，标识在那个切入点何处织入此方法
	 */
	@Before("method()")  
	private void check() {
		System.out.println("-----check-----");
	}
	
}

<?xml version="1.0" encoding="UTF-8"?>

<beans xmlns="http://www.springframework.org/schema/beans"
	     xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
	     xmlns:aop="http://www.springframework.org/schema/aop"
	     xmlns:tx="http://www.springframework.org/schema/tx"
	     xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-2.0.xsd
           http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-2.0.xsd
           http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-2.0.xsd">
	<aop:aspectj-autoproxy/>
	<bean id="myInvocationgHandler" class="com.spring.MyInvocationgHandler"/>           
	<bean id="people" class="com.spring.Student"/>
</beans>

import org.springframework.beans.factory.BeanFactory;
import org.springframework.context.support.ClassPathXmlApplicationContext;
		
public class Client {
		
	public static void main(String[] args) {
		
		BeanFactory factory = new ClassPathXmlApplicationContext("applicationContext.xml");
		
		People people = (People)factory.getBean("people");		
		
		people.say();	
		
		people.run();      		 
	}	
}

		-----check-----
		-----say-----
		-----check-----
		-----run-----

<!--  <aop:aspectj-autoproxy/>  -->
<bean id="myInvocationgHandler" class="com.spring.MyInvocationgHandler"/>           
<bean id="people" class="com.spring.Student"/>

<aop:config>
	<aop:aspect id="security" ref="myInvocationgHandler">        <!-- 配置切面  -->
		<aop:pointcut id="method" expression="execution(* say*(..)) || execution(* run*(..))"/>
		<aop:before method="check" pointcut-ref="method"/>
	</aop:aspect>
</aop:config>

import org.aspectj.lang.JoinPoint;

public class MyInvocationgHandler {		
	
	private void check(JoinPoint joinPoint) {    // 客户端调用代理类方法的时候，调用的参数这里都能拿到
		Object[] args = joinPoint.getArgs();
		for (int i=0; i<args.length; i++) {
			System.out.println(args[i]);
		}
		
		System.out.println(joinPoint.getSignature().getName());   //方法名也都能拿到
		System.out.println("-----check-----");
	}
	
}