SSM Spring 入门（四） 认识Spring中的aop

什么是AOP

• aop思想介绍（面向切面编程）
  将纵向重复代码，横向抽取解决，简称：横切
• Spring中的aop
  无需我们自己写动态代理的代码，spring可以将容器中管理对象生成动态代理对象，前提是我们对他进行一些设置

Spring-aop是基于动态代理的 – 优先选用JDKProxy动态代理

• Proxy动态代理：被代理的对象必须要实现接口
• Cglib动态代理：被代理的对象不能被final修饰，基于继承

术语解释

aop以及动态代理的回忆

• UserService.java

package com.chengyang.service;

public interface UserService {
     
	//增
	void save();
	//删
	void delete();
	//改
	void update();
	//查
	void find();
}

• UserServiceImpl.java

package com.chengyang.service;

public class UserServiceImpl implements UserService {
     

	@Override
	public void save() {
     
		System.out.println("save");
	}

	@Override
	public void delete() {
     
		System.out.println("delete");
		
	}

	@Override
	public void update() {
     
		System.out.println("update");
	}

	@Override
	public void find() {
     
		System.out.println("find");
	}

}

• UserServiceProxy.java

package com.chengyang.test;

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;

import com.chengyang.service.UserService;
import com.chengyang.service.UserServiceImpl;

/*
 * UserServiceProxy代理类
 * 
 * 
 * */
public class UserServiceProxy {
     
	//代理类UserServiceProxy代理UserService
	public UserService getUserServiceProxy(UserService us) {
     
		
		return (UserService) Proxy.newProxyInstance(UserServiceProxy.class.getClassLoader(),
				UserServiceImpl.class.getInterfaces(),
				new InvocationHandler() {
     
					
					@Override
					public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
     
						//增强代码
						System.out.println("开启事务");
						//调用原始的方法
						Object invoke = method.invoke(us, args);
						
						System.out.println("提交/回滚");
						return invoke;
					}
				});
	}

	
}

• AopTest.java

package com.chengyang.test;

import javax.annotation.Resource;

import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.test.context.ContextConfiguration;

import com.chengyang.service.UserService;
import com.chengyang.service.UserServiceImpl;


public class AopTest {
     

	@Test
	public void Test1() {
     
		//创建代理类
		UserServiceProxy usProxy=new UserServiceProxy();
		//创建被代理类
		UserService us=new UserServiceImpl();
		//使用代理类的getUserServiceProxy()方法获得一个增强的UserServiceImpl对象
		UserService us_PowerUp = usProxy.getUserServiceProxy(us);
		//使用被增强过后的UserServiceImpl对象执行  find()方法
		us_PowerUp.find();
	}
}
//out:~~
//开启事务
//find
//提交/回滚

spring aop 配置

• 导包
  i.基本包；
  ii.spring-aspects和spring-aop ；
  iii.aop联盟包 – aopalliance；
  iv.aop织入包 - aspectj.weaver；
  
• 创建自定义通知类 MyAdvice.java

package com.chengyang.aop;

import org.aspectj.lang.ProceedingJoinPoint;

public class MyAdvice {
     

	//before 前置通知 在目标方法前调用
	public void before() {
     
		System.out.println("before");
	}
	//after 最终通知（后置通知）在目标方法后调用 无论是否出现异常都会执行 finally
	public void after() {
     
		System.out.println("after");
	}
	//afterReturning 成功通知（后置通知）在目标方法执行后，并且执行成功，如果方法出现异常就不会调用
	public void afterReturning() {
     
		System.out.println("afterReturning");
	}
	//afterThrowing 异常通知 （后置通知） 在目标方法出现异常的时候才会调用
	public void afterThrowing() {
     
		System.out.println("afterThrowing");
	}
	//around 环绕通知 需要我们手动调用目标方法 并且可以设置通知
	public Object around(ProceedingJoinPoint pjp) throws Throwable {
     
		System.out.println("around before");
		Object proceed = pjp.proceed();
		System.out.println("around after");
		return proceed;
	}
}

将通知织入目标对象

• 创建 applicationContext.xml

先导入约束 aop.xsd 再通过namespace 选择 beans 和 aop

<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-4.3.xsd
		http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-4.3.xsd">
	
	<bean name="userService"  class="com.chengyang.service.UserServiceImpl">bean>
	
	<bean name="myAdvice" class="com.chengyang.aop.MyAdvice">bean>
	
	<aop:config>
		
		<aop:pointcut expression="execution(* com.chengyang.service.UserServiceImpl.*(..))" id="servicePc"/>
		
		<aop:aspect ref="myAdvice">
		
			<aop:before method="before" pointcut-ref="servicePc"/>
			
			<aop:after method="after" pointcut-ref="servicePc"/>
			
			<aop:after-returning method="afterReturning" pointcut-ref="servicePc"/>
			
			<aop:after-throwing method="afterThrowing" pointcut-ref="servicePc"/>
			
			<aop:around method="around" pointcut-ref="servicePc"/>
		aop:aspect>
	aop:config>
beans>

• AopTest.java

package com.chengyang.test;

import javax.annotation.Resource;

import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;

import com.chengyang.service.UserService;
import com.chengyang.service.UserServiceImpl;

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration("classpath:applicationContext.xml")
public class AopTest {
     

	@Resource(name="userService")
	UserService us;
	@Test
	public void Test2() {
     
		us.delete();
	}
}
//out:~~
//before
//around before
//delete
//around after
//afterReturning
//after

本博客为学习笔记，素材源自网络 SIKI学院
侵删