Spring详解（五）——AOP编程语言

package com.ys.aop.one; 
 
public class User { 
	private int uid; 
	private String uname; 
	public int getUid() { 
		return uid; 
	} 
	public void setUid(int uid) { 
		this.uid = uid; 
	} 
	public String getUname() { 
		return uname; 
	} 
	public void setUname(String uname) { 
		this.uname = uname; 
	} 
 
} 

package com.ys.aop.one; 
 
public interface UserService { 
	//添加 user 
	public void addUser(User user); 
	//删除 user 
	public void deleteUser(int uid); 
} 

package com.ys.aop.one; 
 
public class UserServiceImpl implements UserService{ 
	@Override 
	public void addUser(User user) { 
		System.out.println("增加 User"); 
	} 
	@Override 
	public void deleteUser(int uid) { 
		System.out.println("删除 User"); 
	} 
} 

package com.ys.aop.one; 
 
public class MyTransaction { 
	//开启事务 
	public void before(){ 
		System.out.println("开启事务"); 
	} 
	//提交事务 
	public void after(){ 
		System.out.println("提交事务"); 
	} 
} 

package com.ys.aop.one; 
 
public class ProxyUser implements UserService{ 
	//真实类 
	private UserService userService; 
	//事务类 
	private MyTransaction transaction; 
	//使用构造函数实例化 
	public ProxyUser(UserService userService,MyTransaction transaction){ 
		this.userService = userService; 
		this.transaction = transaction; 
	} 
	@Override 
	public void addUser(User user) { 
		transaction.before(); 
		userService.addUser(user); 
		transaction.after(); 
	} 
	@Override 
	public void deleteUser(int uid) { 
		transaction.before(); 
		userService.deleteUser(uid); 
		transaction.after();		 
	} 
} 

@Test 
	public void testOne(){ 
		MyTransaction transaction = new MyTransaction(); 
		UserService userService = new UserServiceImpl(); 
		//产生静态代理对象 
		ProxyUser proxy = new ProxyUser(userService, transaction); 
		proxy.addUser(null); 
		proxy.deleteUser(0); 
	} 

package com.ys.aop.two; 
 
import java.lang.reflect.InvocationHandler; 
import java.lang.reflect.Method; 
import java.lang.reflect.Proxy; 
 
import com.ys.aop.one.MyTransaction; 
 
public class ObjectInterceptor implements InvocationHandler{ 
	//目标类 
	private Object target; 
	//切面类（这里指事务类） 
	private MyTransaction transaction; 
	 
	//通过构造器赋值 
	public ObjectInterceptor(Object target,MyTransaction transaction){ 
		this.target = target; 
		this.transaction = transaction; 
	} 
	 
	@Override 
	public Object invoke(Object proxy, Method method, Object[] args) 
			throws Throwable { 
		//开启事务 
		this.transaction.before(); 
		//调用目标类方法 
		method.invoke(this.target, args); 
		//提交事务 
		this.transaction.after(); 
		return null; 
	} 
	 
} 

@Test 
	public void testOne(){ 
		//目标类 
		Object target = new UserServiceImpl(); 
		//事务类 
		MyTransaction transaction = new MyTransaction(); 
		ObjectInterceptor proxyObject = new ObjectInterceptor(target, transaction); 
		/** 
		 * 三个参数的含义： 
		 * 1、目标类的类加载器 
		 * 2、目标类所有实现的接口 
		 * 3、拦截器 
		 */ 
		UserService userService = (UserService) Proxy.newProxyInstance(target.getClass().getClassLoader(),  
				target.getClass().getInterfaces(), proxyObject); 
		userService.addUser(null); 
	} 

<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" 
       xsi:schemaLocation="http://www.springframework.org/schema/beans  
       					   http://www.springframework.org/schema/beans/spring-beans.xsd 
       					   http://www.springframework.org/schema/aop  
       					   http://www.springframework.org/schema/aop/spring-aop.xsd"> 
	<!--1、 创建目标类 --> 
	<bean id="userService" class="com.ys.aop.UserServiceImpl"></bean>    
	<!--2、创建切面类（通知）  -->  
	<bean id="transaction" class="com.ys.aop.one.MyTransaction"></bean> 
	 
	<!--3、aop编程   
		3.1 导入命名空间 
		3.2 使用 <aop:config>进行配置 
				proxy-target-class="true" 声明时使用cglib代理 
				如果不声明，Spring 会自动选择cglib代理还是JDK动态代理 
			<aop:pointcut> 切入点 ，从目标对象获得具体方法 
			<aop:advisor> 特殊的切面，只有一个通知 和 一个切入点 
				advice-ref 通知引用 
				pointcut-ref 切入点引用 
		3.3 切入点表达式 
			execution(* com.ys.aop.*.*(..)) 
			选择方法         返回值任意   包             类名任意   方法名任意   参数任意 
	 
	--> 
	<aop:config> 
		<!-- 切入点表达式 --> 
		<aop:pointcut expression="execution(* com.ys.aop.*.*(..))" id="myPointCut"/> 
		<aop:aspect ref="transaction"> 
			<!-- 配置前置通知，注意 method 的值要和 对应切面的类方法名称相同 --> 
			<aop:before method="before" pointcut-ref="myPointCut"></aop:before> 
            <aop:after-returning method="after" pointcut-ref="myPointCut"/> 
		</aop:aspect> 
	</aop:config> 
</beans> 

@Test 
	public void testAop(){ 
		ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml"); 
		UserService useService = (UserService) context.getBean("userService"); 
		useService.addUser(null); 
	} 

execution（modifiers-pattern? ref-type-pattern declaring-type-pattern? name-pattern(param-pattern) throws-pattern?） 
　　　　　　　　　　   类修饰符           返回值           方法所在的包                  方法名                     方法抛出的异常 

execution(* com.ys.aop.*.*(..)) 
选择方法         返回值任意   包             类名任意   方法名任意   参数任意