spring-day03
一. spring AOP的入门
1. 什么是AOP，他的主要的作用是什么
-
AOP(Aspect Oriented Programing)面向切面编程，一种编程范式，隶属于软工范畴，指导开发者如 何组织程序结构
-
AOP弥补了OOP的不足，基于OOP基础之上进行横向开发
◆ OOP规定程序开发以类为主体模型，一切围绕对象进行，完成某个任务先构建模型
◆ AOP程序开发主要关注基于OOP开发中的共性功能，一切围绕共性功能进行，完成某个任务先构建可能遇到的所有共性功能(当所有功能都开发出来也就没有共性与非共性之分)
-
“AOP联盟”
-
作用：
- 伴随着AOP时代的降临，可以从各个行业的标准化、规范化开始入手，一步一步将所有共性功能逐一开 发完毕，最终以功能组合来完成个别业务模块乃至整体业务系统的开发
- 目标:将软件开发由手工制作走向半自动化/全自动化阶段，实现“插拔式组件体系结构”搭建
-
AOP优势
- 提高代码的可重用性
- 业务代码编码更简洁
- 业务代码维护更高效
- 业务功能扩展更便捷
2. AOP的核心概念
- Joinpoint(连接点)：项目里面的所有的方法都可以成为连接点
- Pointcut(切入点)：切入点是连接点的一个子集,如果某一个方法需要增强则该方法就是切入点
- Advice(通知,方法)：一个增强的概念-就是一个方法
- Aspect(切面,通知的类)：就是一个类，用来存放通知的
- Target(目标对象)：你自己编写的service对象,dao对象
- Proxy(代理)：根据增强和目标对象生成一个代理对象
- Weaving(织入)：生成代理对象的过程就叫织入
3. AOP的入门程序
-
- 导入两个Jar包
<groupId>org.springframework</groupId> <artifactId>spring-context</artifactId> <version>5.1.9.RELEASE</version> <groupId>org.aspectj</groupId> <artifactId>aspectjweaver</artifactId> <version>1.9.3</version> -
- 编写一个切面类并在该类里面添加对应的通知(方法)
public class AOPAdvice { public void function(){ System.out.println("共性新功能"); } } -
- 创建一个业务接口及实现类
public interface UserService {// public void save(); } public class UserServiceImpl implements UserService { public void save() { System.out.println("UserService 运行了......"); } } -
- 把切面类交给spring来创建和管理
<!--在Spring配置文件applicationContext.xml中--> <!--3.开启AOP命名空间--> xmlns:aop="http://www.springframework.org/schema/aop" http://www.springframework.org/schema/aop https://www.springframework.org/schema/aop/spring-aop.xsd" <!--配置userService的bean--> <bean id="userService" class="com.itheima.service.impl.UserServiceImpl"/> <!--2.配置共性功能成为spring控制的资源--> <bean id="myAdvice" class="com.itheima.aop.AOPAdvice"/> <!--4.配置AOP--> <aop:config> <!--5.配置切入点--> <aop:pointcut id="pt" expression="execution(* *..*(..))"/> <!--6.配置切面（切入点与通知的关系）--> <aop:aspect ref="myAdvice"> <!--7.配置具体的切入点对应通知中那个操作方法--> <aop:before method="function" pointcut-ref="pt"/> </aop:aspect> </aop:config> -
5.测试
public class Day03AppTest { public static void main(String[] args) { ClassPathXmlApplicationContext ctx = new ClassPathXmlApplicationContext("applicationContext.xml"); UserService userService = (UserService) ctx.getBean("userService"); userService.save(); } } //输出结果： 共性新功能 UserService 运行了......
二. spring的切入点表达式
1. 切入点表达式组成
-
切入点描述的是某个方法
关键字(访问修饰符 返回值 包名.类名.方法名(参数)异常名)
- 关键字:描述表达式的匹配模式(参看关键字列表)
- 访问修饰符:方法的访问控制权限修饰符
- 类名:方法所在的类(此处可以配置接口名称)
- 异常:方法定义中指定抛出的异常
//范例 execution(public User com.itheima.service.UserService.findById(int))
2.所有的切入点表达式都是写在execution(）里面的
- 切入点表达式关键字
- execution :匹配执行指定方法
- args :匹配带有指定参数类型的方法
- within :…
- this :…
- target :…
- @within :…
- @target :…
- @args :…
- @annotation :…
- bean :…
- reference pointcut :…
3.切入点表达式——通配符
- * :单个独立的任意符号，可以独立出现，也可以作为前缀或者后缀的匹配符出现
execution(public * com.itheima.*.UserService.find*(*))
//匹配com.itheima包下的任意包中的UserService类或接口中所有find开头的带有一个参数的方法
-
… :多个连续的任意符号，可以独立出现，常用于简化包名与参数的书写
execution(public User com..UserService.findById(..)) // 匹配com包下的任意包中的UserService类或接口中所有名称为findById的方法 -
+:专用于匹配子类类型
execution(* *..*Service+.*(..))
4.范例
execution(* *(..))
execution(* *..*(..))
execution(* *..*.*(..))
execution(public * *..*.*(..))
execution(public int *..*.*(..))
execution(public void *..*.*(..))
execution(public void com..*.*(..))
execution(public void com..service.*.*(..))
execution(public void com.itheima.service.*.*(..))
execution(public void com.itheima.service.User*.*(..))
execution(public void com.itheima.service.*Service.*(..)) execution(public void com.itheima.service.UserService.*(..)) execution(public User com.itheima.service.UserService.find*(..)) execution(public User com.itheima.service.UserService.*Id(..)) execution(public User com.itheima.service.UserService.findById(..)) execution(public User com.itheima.service.UserService.findById(int)) execution(public User com.itheima.service.UserService.findById(int,int)) execution(public User com.itheima.service.UserService.findById(int,*)) execution(public User com.itheima.service.UserService.findById(*,int)) execution(public User com.itheima.service.UserService.findById()) execution(List com.itheima.service.*Service+.findAll(..))
5.切入点配置经验
-
企业开发命名规范严格遵循规范文档进行
-
先为方法配置局部切入点
-
再抽取类中公共切入点
-
最后抽取全局切入点
-
代码走查过程中检测切入点是否存在越界性包含
-
代码走查过程中检测切入点是否存在非包含性进驻
-
设定AOP执行检测程序，在单元测试中监控通知被执行次数与预计次数是否匹配
-
设定完毕的切入点如果发生调整务必进行回归测试
(以上规则适用于XML配置格式)
三. spring的通知
1.Spring的5种通知
前置
执行位置：原始方法执行前执行，如果通知中抛出异常，阻止原始方法运行
应用:数据校验
<aop:before method="before" pointcut-ref="pt"/>
后置
执行位置：原始方法执行后执行，无论原始方法中是否出现异常，都将执行通知
应用:现场清理
<aop:after-returning method="afterReturing" pointcut-ref="pt"/>
最终
执行位置:原始方法正常执行完毕并返回结果后执行，如果原始方法中抛出异常，无法执行
应用:返回值相关数据处理
<aop:after method="after" pointcut-ref="pt"/>
异常
执行位置：始方法抛出异常后执行，如果原始方法没有抛出异常，无法执行
应用:对原始方法中出现的异常信息进行处理
<aop:after-throwing method="afterThrowing" pointcut-ref="pt"/>
public void afterThrowing(Throwable t){}
环绕
执行位置：在原始方法执行前后均有对应执行执行，还可以阻止原始方法的执行
应用：十分强大，可以做任何事情
<aop:around method="around" pointcut-ref="pt"/>
public Object around(ProceedingJoinPoint pjp) {}
2.通知里面获取对应的参数信息
-
在方法的参数上添加一个JoinPoint对象即可
public void function(JoinPoint jp){ Object[] args = jp.getArgs();//获取的是一个数组 System.out.println("共性新功能"+ jp.getArgs()[0]); }
3.获取方法的返回值（只有两种通知能获取）
-
环绕通知
public Object aroundFun(ProceedingJoinPoint pjp){ Object proceed = null; try { proceed = pjp.proceed(); } catch (Throwable throwable) { throwable.printStackTrace(); } System.out.println("around方法---后面...."+ proceed); return proceed; } -
后置通知
-
- 在xml的配置中使用returning配置一个变量的名字
<aop:after-returning method="afterFun" pointcut-ref="pt" returning="o"/> -
- 在通知的方法上添加一个参数-参数的类型一般都是Object的,同时参数的名字一定要跟xml的配置一样
public Object afterFun(Object o){ System.out.println("新添加功能运行了...."+ o); return o; }
-
4.异常的获取
-
环绕通知
-
在调用ret = pjp.proceed();方法的时候添加try…catch即可
public Object around(ProceedingJoinPoint pjp) { System.out.println("around before..."); Object ret = null; try { //对原始方法的调用 ret = pjp.proceed(); } catch (Throwable throwable) { System.out.println("around...exception...."+throwable.getMessage()); } System.out.println("around after..."+ret); return ret; }
-
-
异常通知
-
- 在xml的配置文件中通过throwing属性指定异常对象的名字
<aop:after-throwing method="afterThrowing" pointcut-ref="pt" throwing="t"/> -
- 在通知的方法上添加Throwable类型的参数即可
public void afterThrowing(Throwable t){ System.out.println("afterThrowing..."+t.getMessage()); }
-
四. 注解实现AOP-重点掌握
1. 导入jar包
2. 在spring的核心配置文件中开启aop自动代理
<aop:aspectj-autoproxy/>
3. 编写切面和通知
//接口
public interface UserService {
public void save();
}
//切入点
public class UserServiceImpl implements UserService {
public void save() {
System.out.println("UserService 运行了....");
}
}
//编写切面
public class AOPAdvice {
}
4. 编一个方法加上注解和通知注解
public class AOPAdvice {
//然后在方法上添加@PonitCut("切入点表达式")
@Pointcut("execution(* *..*(..))")
//访问类型为public,返回值为void
public void pc(){}
//在方法上添加对应的通知注解，需要指定他的切入点表达式，就是上面方法的名字
@Before("pc()")
public void function(){
System.out.println("共性新功能......");
}
}
5. 在切面类上添加@Aspect注解
@Component
@Aspect
public class AOPAdvice {
}
五. AOP注解驱动-知道
1.在主配置类上添加@EnableAspectJAutoProxy
@Configuration
@ComponentScan("com.itheima")
@EnableAspectJAutoProxy
public class SpringConfig {
}
六.AOP底层原理–代理
1.静态代理:装饰者模式(Decorator Pattern):在不惊动原始设计的基础上，为其添加功能.
2.动态代理 JDK Proxy:针对对象做代理，要求原始对象具有接口实现，并对接口方法进行增强
public class UserServiceJDKProxy {
public UserService createUserServiceJDKProxy(final UserService userService){
//获取被代理对象的类加载器
ClassLoader classLoader = userService.getClass().getClassLoader();
//获取被代理对象实现的接口
Class[] classes = userService.getClass().getInterfaces();
//对原始方法执行进行拦截并增强
InvocationHandler ih = new InvocationHandler() {
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
//前置增强内容
Object ret = method.invoke(userService, args); //后置增强内容
System.out.println("刮大白2"); return ret;
}
};
//使用原始被代理对象创建新的代理对象
UserService proxy = (UserService) Proxy.newProxyInstance(classLoader,classes,ih);
return proxy;
}
}
3.动态代理 CGLIB:
- CGLIB(Code Generation Library)，Code生成类库
- CGLIB动态代理不限定是否具有接口，可以对任意操作进行增强
- CGLIB动态代理无需要原始被代理对象，动态创建出新的代理对象
public class UserServiceImplCglibProxy {
public static UserServiceImpl createUserServiceCglibProxy(Class clazz){
//创建Enhancer对象(可以理解为内存中动态创建了一个类的字节码)
Enhancer enhancer = new Enhancer();
//设置Enhancer对象的父类是指定类型
UserServerImpl enhancer.setSuperclass(clazz);//步骤1
Callback cb = new MethodInterceptor() { //步骤2
public Object intercept(Object o, Method m, Object[] a, MethodProxy mp) throws Throwable { Object ret = mp.invokeSuper(o, a);//步骤3
if(m.getName().equals("save")) {
System.out.println("刮大白"); }
return ret;
}
};
//设置回调方法 enhancer.setCallback(cb);//步骤4
//使用Enhancer对象创建对应的对象
return (UserServiceImpl)enhancer.create();
}
}
- 经典面试题：jdkproxy和cglib的实现有什么区别？
- jdkproxy通过实现接口的方式
- cglib通过继承类的形式，作为代理对象的子类来操作。
掌握：
- 了解cglib的具体实现
- 掌握jdkproxy的具体实现
七.Spring里面的代理使用
1.spring里面使用的是什么类型的代理？
默认使用的是jdk的代理,同时还可以配置cglib的实现
-
在XML配置文件里进行配置
<aop:config proxy-target-class="false"> </aop:config> -
XML注解支持
<aop:aspectj-autoproxy proxy-target-class="false"/> -
注解驱动
@EnableAspectJAutoProxy(proxyTargetClass = true)
八、织入时机
扫一扫
813
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
