Spring复习04----代理模式-----AOP的实现

静态代理

静态代理模式的实现

一般来说，主要有以下几个步骤

• 抽象一个接口 ISubject （Rent租房）
• 实现该接口 RealSubject （房东）
• 创建代理对象类 ProxySubject （中介）
• 客户端发起调用 （租房的人）

抽象一个接口 ISubject

public interface ISubject {
	
	void doAction(String action);

}

实现该接口 RealSubject

public class RealSubject implements ISubject {
	
	
	public void doAction(String action) {
		// TODO Auto-generated method stub
		System.out.println("I am RealSubject, do action "+ action);
	}

}

创建代理对象类 ProxySubject

public class ProxySubject implements ISubject {
	
	ISubject mRealSubject;
	
	public ProxySubject(ISubject mRealSubject) {
		super();
		this.mRealSubject = mRealSubject;
	}



	public void doAction(String action) {
		// TODO Auto-generated method stub
		preRequest();
		mRealSubject.doAction(action);
		postRequest();
	}



	protected void postRequest() {
		// TODO Auto-generated method stub
		System.out.println("postRequest");
		
	}

	protected void preRequest() {
		// TODO Auto-generated method stub
		System.out.println("preRequest");
		
	}

}

客户端发起调用

	private static void testStatical() {
		RealSubject realSubject = new RealSubject();
		ProxySubject proxySubject = new ProxySubject(realSubject);
		proxySubject.doAction("play");
		
	}

动态代理模式的实现

• 动态代理和静态代理角色一样

• 动态代理的代理类是动态生成的，不是我们写好的

• 动态代理分为两大类：

  • 基于接口的动态代理JDK
  • 基于类的动态代理cglib
  • java 字节码实现 javassist

我们需要两个类：Proxy 代理 和InvocationHandler 调用处理程序

使用 JDK 动态代理，使用 Proxy 类里面的方法创建代理对象

// 方法 1: 该方法用于获取指定代理对象所关联的调用处理器
static InvocationHandler getInvocationHandler(Object proxy) 
 
// 方法 2：该方法用于获取关联于指定类装载器和一组接口的动态代理类的类对象
static Class getProxyClass(ClassLoader loader, Class[] interfaces) 
 
// 方法 3：该方法用于判断指定类对象是否是一个动态代理类
static boolean isProxyClass(Class cl) 
 
// 方法 4：该方法用于为指定类装载器、一组接口及调用处理器生成动态代理类实例
static Object newProxyInstance(ClassLoader loader, Class[] interfaces, 
    InvocationHandler h)
log.csdn.net/gdutxiaoxu/article/details/81394050

java.lang.reflect.InvocationHandler： 这是调用处理器接口，它自定义了一个 invoke 方法，用于集中处理在动态代理类对象上的方法调用，通常在该方法中实现对委托类的代理访问。

// 该方法负责集中处理动态代理类上的所有方法调用。第一个参数既是代理类实例，第二个参数是被调用的方法对象
// 第三个方法是调用参数。调用处理器根据这三个参数进行预处理或分派到委托类实例上发射执行
Object invoke(Object proxy, Method method, Object[] args)

实现步骤：

• 实现 InvocationHandler 接口，创建自己的调用处理器；
• 为 Proxy 类指定 ClassLoader 对象和一组 interface ，从而来创建动态代理类；
• 反射机制获得动态代理类的构造函数，其唯一参数类型是调用处理器接口类型；
• 通过构造函数创建动态代理类实例，构造时调用处理器对象作为参数被传入。

// InvocationHandlerImpl 实现了 InvocationHandler 接口，并能实现方法调用从代理类到委托类的分派转发
// 其内部通常包含指向委托类实例的引用，用于真正执行分派转发过来的方法调用
InvocationHandler handler = new InvocationHandlerImpl(..); 
 
// 通过 Proxy 为包括 Interface 接口在内的一组接口动态创建代理类的类对象
Class clazz = Proxy.getProxyClass(classLoader, new Class[] { Interface.class, ... }); 
 
// 通过反射从生成的类对象获得构造函数对象
Constructor constructor = clazz.getConstructor(new Class[] { InvocationHandler.class }); 
 
// 通过构造函数对象创建动态代理类实例
Interface Proxy = (Interface)constructor.newInstance(new Object[] { handler });

实际使用过程更加简单，因为 Proxy 的静态方法 newProxyInstance 已经为我们封装了步骤 2 到步骤 4 的过程，所以简化后的过程如下：

• 实现 InvocationHandler 接口，创建自己的调用处理器；
• 通过 Proxy.newProxyInstance 生成动态代理类实例

// InvocationHandlerImpl 实现了 InvocationHandler 接口，并能实现方法调用从代理类到委托类的分派转发
InvocationHandler handler = new InvocationHandlerImpl(..); 
 
// 通过 Proxy 直接创建动态代理类实例
Interface proxy = (Interface)Proxy.newProxyInstance( classLoader, 
     new Class[] { Interface.class }, 
     handler );

• 创建 ISubject
• 实现 RealSubject
• 通过 Proxy.newInstance 生成动态代理对象

public class DynamicProxyHandler implements InvocationHandler {

	private Object target;

	public DynamicProxyHandler(Object target) {
		this.target = target;
	}

	public <T> T getProxy() {
		return (T) Proxy.newProxyInstance(target.getClass().getClassLoader(),
				target.getClass().getInterfaces(), this);
	}

	public Object invoke(Object proxy, Method method, Object[] args)
			throws Throwable {
		System.out.println("办事之前先收取点费用");
		System.out.println("开始办事");
		Object result = null;
		try {
			result = method.invoke(target, args);
		} catch (IllegalAccessException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		} catch (IllegalArgumentException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		} catch (InvocationTargetException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
		System.out.println("办完了");
		return result;
	}

	

}

输出------>

办事之前先收取点费用
开始办事
I am RealSubject, do action play
办完了

aop实现方式

切入点：实际被增强的方法叫切入点
连接点：类里面哪些方法被增强了，叫做连接点

切入点表达式

（1）切入点表达式作用：知道对哪个类里面的哪个方法进行增强
（2）语法结构： execution([权限修饰符] [返回类型] [类全路径] [方法名称] ([参数列表]) )

举例 1：对 com.atguigu.dao.BookDao 类里面的 add 进行增强
execution(* com.atguigu.dao.BookDao.add(…))
举例 2：对 com.atguigu.dao.BookDao 类里面的所有的方法进行增强
execution(* com.atguigu.dao.BookDao.* (…))举例 3：对 com.atguigu.dao 包里面所有类，类里面所有方法进行增强
execution(* com.atguigu.dao.. (…))

实现方式1

<aop:pointcut id="pointer" expression="execution(* com.ty.dao.UserDaoImp.*(..)) "
<aop:advisor advice-ref="beforeLog" pointcut-ref="pointer"></aop:advisor>-->
<aop:advisor advice-ref="afterLog" pointcut-ref="pointer"></aop:advisor>-->

实现方式2

<aop:aspect id="aspect1" ref="defineClass">-->
    <aop:pointcut id="pointer1" expression="execution(* com.ty.dao.UserDaoImp.*(..))"
    <aop:before method="before" pointcut-ref="pointer1"></aop:before>-->
    <aop:after method="after" pointcut-ref="pointer1"></aop:after>-->
 </aop:aspect>-->

实现方式3（注解方式）

引入注解支持

<!--配置注解支持-->
    <aop:aspectj-autoproxy></aop:aspectj-autoproxy>

@Aspect
public class AnnotationDefine {
    @Before("execution(* com.ty.dao.UserDaoImp.*(..))")
    public void before(){
        System.out.println("方法执行前.......");
    }
    @After("execution(* com.ty.dao.UserDaoImp.*(..))")
    public  void after(){
        System.out.println("方法执行后.......");
    }

}