AOP__使用JDK中的Proxy技术实现AOP功能

AOP主要用于权限的验证

细粒度的权限控制：对方法进行拦截，判断用户是否用权限，假如有权限，则允许用户访问被拦截的方法

粗粒度的权限控制：

机制：方法——代理对象——目标对象

实例：使用JDK中的Proxy技术实现AOP功能模拟AOP的机制(不使用任何AOP框架)

局限性：目标对象PersonServiceImp需要实现接口

 PersonService.java

package com.qh.service;
//接口
public interface PersonService {
	public void save(String name);

	public void update(String name, int id);

	public String getPersonName(int id);
}

 PersonServiceImp.java

/**
 * 业务层，被拦截对象
 */
package com.qh.service.imp;
import com.qh.service.PersonService;
public class PersonServiceImp implements PersonService {
	String user = null;//用户
	// 获得用户信息的方法
	public String getUser() {
		return user;
	}
	public PersonServiceImp() {
	}
	public PersonServiceImp(String user) {
		this.user = user;
	}
	public void save(String name) {
		System.out.println("我是save()方法");
	}
	public void update(String name, int id) {
		System.out.println("我是update()方法");
	}
	public String getPersonName(int id) {
		return "我是getPersonName()方法";
	}
}

 JDKProxyFactory.java

/*
 * proxy工厂，拦截所有业务方法，判断user是否为null,为null,则没有权限访问方法
 */
package com.qh.aop;

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
import com.qh.service.imp.PersonServiceImp;

public class JDKProxyFactory implements InvocationHandler {// 实现接口
	private Object targetObject;// 目标对象

	/*
	 * 创建一个Proxy实例，参数说明：获得目标类的装载、代理对象实现的接口、 
	 * 回调(当实现前两个参数后，调用类的拦截方法(invoke()方法))
	 */
	public Object createProxyIntance(Object targetObject) {
		this.targetObject = targetObject;
		return Proxy.newProxyInstance(this.targetObject.getClass()
				.getClassLoader(),
				this.targetObject.getClass().getInterfaces(), this);
	}
	//此方法是接口InvocationHandler中的方法，是Proxy的核心方法
	// 参数说明：代理对象、拦截的方法、拦截方法的输入参数
	public Object invoke(Object poxy, Method method, Object[] args)
			throws Throwable {
		PersonServiceImp personServiceImp = (PersonServiceImp) this.targetObject;
		Object result = null;
		if (personServiceImp.getUser() != null) {
			// 将拦截的方法委派给目标对象
			result = method.invoke(this.targetObject, args);
		}
		return result;
	}
}

  Test.java

package com.qh.test;

import org.junit.Test;

import com.qh.aop.JDKProxyFactory;
import com.qh.service.PersonService;
import com.qh.service.imp.PersonServiceImp;

public class AOPTest {

	@Test
	public void test() {
		JDKProxyFactory factory = new JDKProxyFactory();
		//用接口创建对象
		PersonService personServiceImp = (PersonService) factory
				.createProxyIntance(new PersonServiceImp("aa"));//传入目标对象
		personServiceImp.save("fdf");
	}

}