Spring学习 Spring AOP
4.Spring AOP
4.1.为什么要学习AOP?
-
案例：有一个接口Service有一个addUser方法，在调用addUser(被调用时打印调用前的毫秒数与调用后的毫秒数），其实现为：
@Service public class UserServiceImpl implements UserService { @Autowired private UserDao userDao; public void addUser(){ System.out.println("方法开始时间："+new Date()); userDao.addUser(); System.out.println("方法结束时间："+new Date()); } } -
问题：输出日志的逻辑还是无法复用
4.2.AOP概述
AOP：全称是Aspect Oriented Programming即：面向切面编程。
简单的说它就是把我们程序重复的代码抽取出来，在需要执行的时候，使用动态代理的技术，在不修改源码的基础上，对程序进行增强：权限校验,日志记录,性能监控,事务控制.
4.3.代理（Proxy）模式
4.3.1.创建工程
4.3.2.代理（Proxy）模式介绍
-
作用：通过代理可以控制访问某个对象的方法，在调用这个方法前做前置处理，调用这个方法后做后置处理。（即： AOP的微观实现！）
-
核心角色
-
抽象角色(接口)：定义公共对外方法
-
真实角色（周杰伦）：实现抽象角色，定义真实角色所要实现的业务逻辑，
-
代理角色（代理人）：实现抽象角色，是真实角色的代理，通过调用真实角色的方法来完成业务逻辑，并可以附加自己的操作。
-
4.3.3.静态代理
4.3.3.1.抽象角色
package com.by.proxy.StaticProxy;
public interface Star {
/**
* 面谈
*/
void confer();
/**
* 签合同
*/
void signContract();
/**
* 订票
*/
void bookTicket();
/**
* 唱歌
*/
void sing();
/**
* 收钱
*/
void collectMoney();
}
4.3.3.2.真正角色（周杰伦）
package com.by.proxy.StaticProxy;
public class RealStar implements Star {
public void bookTicket() {
}
public void collectMoney() {
}
public void confer() {
}
public void signContract() {
}
public void sing() {
System.out.println("RealStar(周杰伦本人).sing()");
}
}
4.3.3.3.代理角色（经纪人）
package com.by.proxy.StaticProxy;
public class ProxyStar implements Star {
private Star star;
public ProxyStar(Star star) {
super();
this.star = star;
}
public void bookTicket() {
System.out.println("ProxyStar.bookTicket()");
}
public void collectMoney() {
System.out.println("ProxyStar.collectMoney()");
}
public void confer() {
System.out.println("ProxyStar.confer()");
}
public void signContract() {
System.out.println("ProxyStar.signContract()");
}
public void sing() {
star.sing();
}
}
4.3.3.4.测试
package com.by.proxy.StaticProxy;
public class Client {
public static void main(String[] args) {
Star proxy = new ProxyStar(new RealStar());
proxy.confer();
proxy.signContract();
proxy.bookTicket();
proxy.sing();
proxy.collectMoney();
}
}
4.3.3.5.静态代理的缺点
- 代理类和实现类实现了相同的接口，这样就出现了大量的代码重复。
- 代理对象只服务于一种类型的对象。如果要服务多类型的对象，例如代码是只为UserService类的访问提供了代理，但是还要为其他类如DeptService类提供代理的话，就需要我们再次添加代理DeptService的代理类。
4.3.4.jdk动态代理
4.3.4.1.抽象角色
public interface Star {
/**
* 唱歌
*/
void sing();
}
4.3.4.2.真正角色（周杰伦）
package com.by.JdkProxy;
//真实角色(周杰伦)
public class RealStar implements Star {
//优点：此时代码不再重复
public void sing() {
System.out.println("周杰伦：快使用双截棍,哼哼哈嘿....");
}
}
4.3.4.3.代理工厂
package com.by.JdkProxy;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
//代理类工厂
public class ProxyFactory {
//优点：此时可以代理任意类型的对象
//真实角色(周杰伦)
private Object realObj;
public ProxyFactory(Object realObj) {
this.realObj = realObj;
}
//获得代理对象
public Object getProxyObject(){
/**
* Proxy：作用创建代理对象
* ClassLoader loader：类加载器
* Class[] interfaces：真实角色实现的接口，根据接口生成代理类
* InvocationHandler h：增强的逻辑，即如何代理(宋吉吉要做的事)
*/
return Proxy.newProxyInstance(
realObj.getClass().getClassLoader(),
realObj.getClass().getInterfaces(),
new InvocationHandler() {
/**
*
* @param proxy：代理类，一般不用
* @param method：要调用的方法
* @param args：调用方法时的参数
* @return
* @throws Throwable
*/
public Object invoke(Object proxy, Method method, Object[] args)
throws Throwable {
System.out.println("真正的方法执行前！");
System.out.println("面谈，签合同，预付款，订机票");
Object result = method.invoke(realObj, args);
System.out.println("真正的方法执行后！");
System.out.println("收尾款");
return result;
}
}
);
}
}
4.3.4.4.测试
public class Client {
public static void main(String[] args) {
//获得代理对象
Star proxyObject = (Star) new ProxyFactory(new RealStar()).getProxyObject();
System.out.println(proxyObject.getClass());//class com.sun.proxy.$Proxy0
proxyObject.sing();
}
}
4.3.5.Cglib动态代理
cglib与动态代理最大的区别就是：
- 使用jdk动态代理的对象必须实现一个接口
- 使用cglib代理的对象则无需实现接口
CGLIB是第三方提供的包，所以需要引入jar包的坐标：
<dependency>
<groupId>cglibgroupId>
<artifactId>cglibartifactId>
<version>2.2.2version>
dependency>
如果你已经有spring-core的jar包，则无需引入，因为spring中包含了cglib。
4.3.5.1.真正角色
package com.by.proxy.CglibProxy;
public class RealStar{
public void sing() {
System.out.println("RealStar(周杰伦本人).sing()");
}
}
4.3.5.2.代理角色（经纪人）
package com.by.proxy.CglibProxy;
import org.springframework.cglib.proxy.Enhancer;
import org.springframework.cglib.proxy.MethodInterceptor;
import org.springframework.cglib.proxy.MethodProxy;
import java.lang.reflect.Method;
//代理工厂
public class ProxyFactory implements MethodInterceptor {
//真实角色
private Object realObj;
public ProxyFactory(Object realObj) {
this.realObj = realObj;
}
/**'
* 获得子类代理对象
* @return
*/
public Object getProxyObject() {
//工具类
Enhancer en = new Enhancer();
//设置父类
en.setSuperclass(realObj.getClass());
//设置回调函数
en.setCallback(this);
//创建子类代理对象
return en.create();
}
/*
在子类中调用父类的方法
intercept方法参数说明：
obj ： 代理对象
method ： 真实对象中的方法的Method实例
args ： 实际参数
methodProxy ：代理对象中的方法的method实例
*/
public Object intercept(Object obj, Method method, Object[] args,
MethodProxy methodProxy)throws Throwable {
System.out.println("真正的方法执行前！");
System.out.println("面谈，签合同，预付款，订机票");
Object result = method.invoke(realObj, args);
System.out.println("真正的方法执行后！");
System.out.println("收尾款");
return object;
}
}
4.3.5.3.测试
package com.by.proxy.CglibProxy;
//测试类
public class Client {
public static void main(String[] args) {
//获取代理对象
RealStar proxyObject =
(RealStar) new ProxyFactory(new RealStar()).getProxyObject();
proxyObject.sing();
}
}
4.4.AOP相关术语
-
连接点（joinpoint）
被拦截到的点，因为Spring只支持方法类型的连接点，所以在Spring中连接点指的就是被拦截到的方法。
-
切入点（pointcut）
切入点是指我们要对哪些连接点进行拦截的定义
-
通知（advice）
所谓通知指的就是指拦截到连接点之后要执行的代码，通知分为前置、后置、异常、最终、环绕通知五类
-
切面（aspect）
是切入点和通知的结合
-
引介（introduction）
是一种特殊的通知，在不修改代码的前提下，引介可以在运行期为类动态地添加一些方法或字段
-
目标对象（Target）
要代理的目标对象（要增强的类）
-
织入（weave）
将增强应用到目标的过程将advice应用到target的过程
-
代理（Proxy）
一个类被AOP织入增强之后，就产生一个代理类
4.5.Spring的AOP配置
4.5.1.创建工程
4.5.1.1.pom.xml
<project xmlns="http://maven.apache.org/POM/4.0.0"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
<modelVersion>4.0.0modelVersion>
<groupId>com.bygroupId>
<artifactId>Spring_AOP_XmlartifactId>
<version>1.0-SNAPSHOTversion>
<dependencies>
<dependency>
<groupId>org.springframeworkgroupId>
<artifactId>spring-contextartifactId>
<version>5.1.8.RELEASEversion>
dependency>
<dependency>
<groupId>org.springframeworkgroupId>
<artifactId>spring-aspectsartifactId>
<version>5.1.8.RELEASEversion>
dependency>
dependencies>
project>
4.5.1.2.dao
/**
* 持久层实现类
*/
public class UserDaoImpl implements UserDao {
@Override
public void addUser(){
System.out.println("insert into tb_user......");
}
}
4.5.1.3.service
/**
* 业务层实现类
*/
public class UserServiceImpl implements UserService {
private UserDao userDao;
public void setUserDao(UserDao userDao){
this.userDao=userDao;
}
@Override
public void addUser(){
userDao.addUser();
}
}
4.5.1.4.applicationContext.xml
<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">
<bean id="userDao" class="com.by.dao.UserDaoImpl">bean>
<bean id="userService" class="com.by.service.UserServiceImpl">
<property name="userDao" ref="userDao">property>
bean>
beans>
4.5.1.5.web
/**
* 模拟表现层
*/
public class Client {
public static void main(String[] args) {
ApplicationContext ac =
new ClassPathXmlApplicationContext("applicationContext.xml");
//使用对象
UserService userService = ac.getBean("userService",UserService.class);
System.out.println(userService.getClass());
userService.addUser();
}
}
4.5.2.增强
-
创建增强类
package com.by.advice; import org.aspectj.lang.ProceedingJoinPoint; import java.util.Date; public class MyLogAdvice { //前置通知 public void before(){ System.out.println("前置通知"); } //后置通知【try】 public void afterReturning(){ System.out.println("后置通知"); } //异常通知【catch】 public void afterThrowing(){ System.out.println("异常通知"); } //最终通知【finally】 public void after(){ System.out.println("最终通知"); } //环绕通知 public void around(ProceedingJoinPoint joinPoint){ try { System.out.println("方法执行前的环绕通知"); joinPoint.proceed(); System.out.println("方法执行后的环绕通知"); } catch (Throwable throwable) { throwable.printStackTrace(); } } } -
配置增强类
<bean id="myLogger" class="com.by.advice.MyLogger">bean>
4.5.3.切点
-
切点表达式
表达式语法：
execution([修饰符] 返回值类型 包名.类名.方法名(参数))例如：
execution(* com.by.service.UserService.add(..))
execution(* com.by.service.UserService.*(..))
execution(* com.by.service.*.*(..)) -
配置切点
<aop:config> <aop:pointcut id="pointcut" expression="execution(* com.by.service.*.*(..))"/> aop:config>
4.5.4.切面
-
增强的类型
- aop:before：用于配置前置通知
- aop:after-returning：用于配置后置【try】通知，它和异常通知只能有一个执行
- aop:after-throwing：用于配置异常【catch】通知，它和后置通知只能执行一个
- aop:after：用于配置最终【finally】通知
- aop:around：用于配置环绕通知
-
配置切面
<aop:aspect ref="myLogger"> <aop:before method="before" pointcut-ref="pointcut"/> <aop:after-returning method="afterReturning" pointcut-ref="pointcut"/> <aop:after-throwing method="afterThrowing" pointcut-ref="pointcut"/> <aop:after method="after" pointcut-ref="pointcut"/> <aop:around method="around" pointcut-ref="pointcut"/> aop:aspect>
4.5.5.测试
-
测试service实现接口时的类型
-
测试service不实现接口时的类型
