AOP 与 Spring中AOP使用（下）
AOP通知类型
前置通知
在目标方法执行之前进行操作
UserDao.java
public class UserDao {
public void add(){
System.out.println("添加用户");
}
}
切面类 MyAspect.java
public class MyAspect {
public void check(){
System.out.println("权限校验");
}
}
applicationContext.xml 配置：
<?xml version="1.0" encoding="UTF-8"?>
<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.xzh.spring.demo4.UserDao"/>
<bean id="myAspect" class="com.xzh.spring.demo4.MyAspect"/>
<!--配置AOP-->
<aop:config>
<!--切点：给那个方法做增强-->
<aop:pointcut id="point1" expression="execution(* com.xzh.spring.demo4.UserDao.add(..))"/>
<!--配置切面：增强的功能是什么-->
<aop:aspect ref="myAspect">
<!--前置通知-->
<aop:before method="check" pointcut-ref="point1"/>
</aop:aspect>
</aop:config>
</beans>
AOP测试：
@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration("classpath:applicationContext.xml")
public class AopTest {
@Resource(name = "userDao")
private UserDao userDao;
@Test
public void test() {
this.userDao.add();
}
}
后置通知
在目标方法执行之后 进行操作
UserDao.java
public class UserDao {
public void add(){
System.out.println("添加用户");
}
public void update(){
System.out.println("更新用户");
}
}
切面类 MyAspect.java
public class MyAspect {
public void check(){
System.out.println("权限校验");
}
public void log(){
System.out.println("日志记录");
}
}
applicationContext.xml 配置：
<?xml version="1.0" encoding="UTF-8"?>
<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.xzh.spring.demo4.UserDao"/>
<bean id="myAspect" class="com.xzh.spring.demo4.MyAspect"/>
<!--配置AOP-->
<aop:config>
<!--切点：给那个方法做增强-->
<aop:pointcut id="point1" expression="execution(* com.xzh.spring.demo4.UserDao.add(..))"/>
<aop:pointcut id="point2" expression="execution(* com.xzh.spring.demo4.UserDao.update(..))"/>
<!--配置切面：增强的功能是什么-->
<aop:aspect ref="myAspect">
<!--前置通知-->
<aop:before method="check" pointcut-ref="point1"/>
<!--后置通知-->
<aop:after-returning method="log" pointcut-ref="point2"/>
</aop:aspect>
</aop:config>
</beans>
AOP测试：
@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration("classpath:applicationContext.xml")
public class AopTest {
@Resource(name = "userDao")
private UserDao userDao;
@Test
public void test() {
this.userDao.update();
}
}
后置通知获取切入点的返回值
UserDao.java
public class UserDao {
public void add(){
System.out.println("添加用户");
}
public String update(){
System.out.println("更新用户");
return "更新成功!";
}
}
切面类 MyAspect.java
public class MyAspect {
public void check(){
System.out.println("权限校验");
}
public void log(Object res){
System.out.println("日志记录:" + res);
}
}
applicationContext.xml 配置：
<?xml version="1.0" encoding="UTF-8"?>
<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.xzh.spring.demo4.UserDao"/>
<bean id="myAspect" class="com.xzh.spring.demo4.MyAspect"/>
<!--配置AOP-->
<aop:config>
<!--切点：给那个方法做增强-->
<aop:pointcut id="point1" expression="execution(* com.xzh.spring.demo4.UserDao.add(..))"/>
<aop:pointcut id="point2" expression="execution(* com.xzh.spring.demo4.UserDao.update(..))"/>
<!--配置切面：增强的功能是什么-->
<aop:aspect ref="myAspect">
<!--前置通知-->
<aop:before method="check" pointcut-ref="point1"/>
<!--后置通知-->
<aop:after-returning method="log" pointcut-ref="point2" returning="res"/>
</aop:aspect>
</aop:config>
</beans>
AOP测试：
@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration("classpath:applicationContext.xml")
public class AopTest {
@Resource(name = "userDao")
private UserDao userDao;
@Test
public void test() {
this.userDao.update();
}
}
环绕通知
在目标方法执行之前 和之后进行操作
UserDao.java
public class UserDao {
public void add(){
System.out.println("添加用户");
}
public String update(){
System.out.println("更新用户");
return "更新成功!";
}
public void delete(){
System.out.println("删除用户");
}
}
切面类 MyAspect.java
public class MyAspect {
public void check(){
System.out.println("权限校验");
}
public void log(Object res){
System.out.println("日志记录:" + res);
}
public Object around(ProceedingJoinPoint joinPoint) throws Throwable {
System.out.println("开启事务");
Object proceed = joinPoint.proceed();
System.out.println("提交事务");
return proceed;
}
}
applicationContext.xml 配置：
<?xml version="1.0" encoding="UTF-8"?>
<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.xzh.spring.demo4.UserDao"/>
<bean id="myAspect" class="com.xzh.spring.demo4.MyAspect"/>
<!--配置AOP-->
<aop:config>
<!--切点：给那个方法做增强-->
<aop:pointcut id="point1" expression="execution(* com.xzh.spring.demo4.UserDao.add(..))"/>
<aop:pointcut id="point2" expression="execution(* com.xzh.spring.demo4.UserDao.update(..))"/>
<aop:pointcut id="point3" expression="execution(* com.xzh.spring.demo4.UserDao.delete(..))"/>
<!--配置切面：增强的功能是什么-->
<aop:aspect ref="myAspect">
<!--前置通知-->
<aop:before method="check" pointcut-ref="point1"/>
<!--后置通知-->
<aop:after-returning method="log" pointcut-ref="point2" returning="res"/>
<!--环绕通知-->
<aop:around method="around" pointcut-ref="point3"/>
</aop:aspect>
</aop:config>
</beans>
AOP测试：
@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration("classpath:applicationContext.xml")
public class AopTest {
@Resource(name = "userDao")
private UserDao userDao;
@Test
public void test() {
this.userDao.delete();
}
}
异常抛出通知
在程序出现异常时进行操作
UserDao.java
public class UserDao {
public void add(){
System.out.println("添加用户");
}
public String update(){
System.out.println("更新用户");
return "更新成功!";
}
public void delete(){
System.out.println("删除用户");
}
public void find(){
System.out.println("查找用户");
int i = 1 / 0;
}
}
切面类 MyAspect.java
public class MyAspect {
public void check(){
System.out.println("权限校验");
}
public void log(Object res){
System.out.println("日志记录:" + res);
}
public Object around(ProceedingJoinPoint joinPoint) throws Throwable {
System.out.println("开启事务");
Object proceed = joinPoint.proceed();
System.out.println("提交事务");
return proceed;
}
public void exceptionMethod(){
System.out.println("有异常");
}
}
applicationContext.xml 配置：
<?xml version="1.0" encoding="UTF-8"?>
<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.xzh.spring.demo4.UserDao"/>
<bean id="myAspect" class="com.xzh.spring.demo4.MyAspect"/>
<!--配置AOP-->
<aop:config>
<!--切点：给那个方法做增强-->
<aop:pointcut id="point1" expression="execution(* com.xzh.spring.demo4.UserDao.add(..))"/>
<aop:pointcut id="point2" expression="execution(* com.xzh.spring.demo4.UserDao.update(..))"/>
<aop:pointcut id="point3" expression="execution(* com.xzh.spring.demo4.UserDao.delete(..))"/>
<aop:pointcut id="point4" expression="execution(* com.xzh.spring.demo4.UserDao.find(..))"/>
<!--配置切面：增强的功能是什么-->
<aop:aspect ref="myAspect">
<!--前置通知-->
<aop:before method="check" pointcut-ref="point1"/>
<!--后置通知-->
<aop:after-returning method="log" pointcut-ref="point2" returning="res"/>
<!--环绕通知-->
<aop:around method="around" pointcut-ref="point3"/>
<!--异常抛出通知-->
<aop:after-throwing method="exceptionMethod" pointcut-ref="point4"/>
</aop:aspect>
</aop:config>
</beans>
AOP测试：
@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration("classpath:applicationContext.xml")
public class AopTest {
@Resource(name = "userDao")
private UserDao userDao;
@Test
public void test() {
this.userDao.find();
}
}
异常抛出通知获取异常信息
UserDao.java
public class UserDao {
public void add(){
System.out.println("添加用户");
}
public String update(){
System.out.println("更新用户");
return "更新成功!";
}
public void delete(){
System.out.println("删除用户");
}
public void find(){
System.out.println("查找用户");
int i = 1 / 0;
}
}
切面类 MyAspect.java
public class MyAspect {
public void check(){
System.out.println("权限校验");
}
public void log(Object res){
System.out.println("日志记录:" + res);
}
public Object around(ProceedingJoinPoint joinPoint) throws Throwable {
System.out.println("开启事务");
Object proceed = joinPoint.proceed();
System.out.println("提交事务");
return proceed;
}
public void exceptionMethod(Throwable ex){
System.out.println("有异常:" + ex.getMessage());
}
}
applicationContext.xml 配置：
<?xml version="1.0" encoding="UTF-8"?>
<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.xzh.spring.demo4.UserDao"/>
<bean id="myAspect" class="com.xzh.spring.demo4.MyAspect"/>
<!--配置AOP-->
<aop:config>
<!--切点：给那个方法做增强-->
<aop:pointcut id="point1" expression="execution(* com.xzh.spring.demo4.UserDao.add(..))"/>
<aop:pointcut id="point2" expression="execution(* com.xzh.spring.demo4.UserDao.update(..))"/>
<aop:pointcut id="point3" expression="execution(* com.xzh.spring.demo4.UserDao.delete(..))"/>
<aop:pointcut id="point4" expression="execution(* com.xzh.spring.demo4.UserDao.find(..))"/>
<!--配置切面：增强的功能是什么-->
<aop:aspect ref="myAspect">
<!--前置通知-->
<aop:before method="check" pointcut-ref="point1"/>
<!--后置通知-->
<aop:after-returning method="log" pointcut-ref="point2" returning="res"/>
<!--环绕通知-->
<aop:around method="around" pointcut-ref="point3"/>
<!--异常抛出通知-->
<aop:after-throwing method="exceptionMethod" pointcut-ref="point4" throwing="ex"/>
</aop:aspect>
</aop:config>
</beans>
AOP测试：
@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration("classpath:applicationContext.xml")
public class AopTest {
@Resource(name = "userDao")
private UserDao userDao;
@Test
public void test() {
this.userDao.find();
}
}
最终通知
无论代码是否有异常，都会执行
UserDao.java
public class UserDao {
public void add(){
System.out.println("添加用户");
}
public String update(){
System.out.println("更新用户");
return "更新成功!";
}
public void delete(){
System.out.println("删除用户");
}
public void find(){
System.out.println("查找用户");
int i = 1 / 0;
}
}
切面类 MyAspect.java
public class MyAspect {
public void check(){
System.out.println("权限校验");
}
public void log(Object res){
System.out.println("日志记录:" + res);
}
public Object around(ProceedingJoinPoint joinPoint) throws Throwable {
System.out.println("开启事务");
Object proceed = joinPoint.proceed();
System.out.println("提交事务");
return proceed;
}
public void exceptionMethod(Throwable ex){
System.out.println("有异常:" + ex.getMessage());
}
public void after(){
System.out.println("最终通知");
}
}
applicationContext.xml 配置：
<?xml version="1.0" encoding="UTF-8"?>
<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.xzh.spring.demo4.UserDao"/>
<bean id="myAspect" class="com.xzh.spring.demo4.MyAspect"/>
<!--配置AOP-->
<aop:config>
<!--切点：给那个方法做增强-->
<aop:pointcut id="point1" expression="execution(* com.xzh.spring.demo4.UserDao.add(..))"/>
<aop:pointcut id="point2" expression="execution(* com.xzh.spring.demo4.UserDao.update(..))"/>
<aop:pointcut id="point3" expression="execution(* com.xzh.spring.demo4.UserDao.delete(..))"/>
<aop:pointcut id="point4" expression="execution(* com.xzh.spring.demo4.UserDao.find(..))"/>
<!--配置切面：增强的功能是什么-->
<aop:aspect ref="myAspect">
<!--前置通知-->
<aop:before method="check" pointcut-ref="point1"/>
<!--后置通知-->
<aop:after-returning method="log" pointcut-ref="point2" returning="res"/>
<!--环绕通知-->
<aop:around method="around" pointcut-ref="point3"/>
<!--异常抛出通知-->
<aop:after-throwing method="exceptionMethod" pointcut-ref="point4" throwing="ex"/>
<!--最终通知-->
<aop:after method="after" pointcut-ref="point4"/>
</aop:aspect>
</aop:config>
</beans>
AOP测试：
@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration("classpath:applicationContext.xml")
public class AopTest {
@Resource(name = "userDao")
private UserDao userDao;
@Test
public void test() {
this.userDao.find();
}
}
AOP切入点表达式
- 基于execution函数完成
execution语法：
【访问修饰符】 方法返回值 包名.类名.方法名（参数）
public com.myxq.demo2.GoodsDaoImpl.save(..) // 参数为任意参数
* com.myxq.demo2.GoodsDaoImpl.save(..) // * 为任意类型
* com.myxq.demo2.GoodsDaoImpl+.save(..) // + 当前类和子类
* com.myxq..*.*(..) // com.myxq包以及子包下面所有类的所有方法
AOP注解方式ApsectJ开发
GoodsDao 接口：
public interface GoodsDao {
public void save();
public String update();
public void delete();
public void find();
}
GoodsDao 实现类 GoodsDaoImpl：
public class GoodsDaoImpl implements GoodsDao {
@Override
public void save() {
System.out.println("保存操作");
}
@Override
public String update() {
System.out.println("更新操作");
return "更新完成";
}
@Override
public void delete() {
System.out.println("删除操作");
}
@Override
public void find() {
System.out.println("查询操作");
int i = 1 / 0;
}
}
1. 引入Jar包
2. 引入配置文件
applicationContext.xml
<?xml version="1.0" encoding="UTF-8"?>
<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">
</beans>
3. 编写切面类配置
public class GoodsDaoAspect {
public void log(){
System.out.println("前置增强");
}
}
将切面类交给 spring 管理，applicationContext.xml 配置：
<?xml version="1.0" encoding="UTF-8"?>
<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="goodsDao" class="com.xzh.spring.demo5.GoodsDaoImpl"/>
<bean id="goodsAspect" class="com.xzh.spring.demo5.GoodsDaoAspect"/>
</beans>
4. 使用注解的AOP对象目标类进行增强
在配置文件 applicationContext.xml 中开启以注解形式进行AOP开发
<?xml version="1.0" encoding="UTF-8"?>
<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">
<!--AOP配置开启注解-->
<aop:aspectj-autoproxy/>
<bean id="goodsDao" class="com.xzh.spring.demo5.GoodsDaoImpl"/>
<bean id="goodsAspect" class="com.xzh.spring.demo5.GoodsDaoAspect"/>
</beans>
在切面类上添加注解
@Aspect
public class GoodsDaoAspect {
@Before(value = "execution(* com.xzh.spring.demo5.GoodsDaoImpl.save(..))")
public void before(){
System.out.println("前置增强");
}
}
测试
@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration("classpath:applicationContext.xml")
public class GoodsTest {
@Resource(name = "goodsDao")
private GoodsDao goodsDao;
@Test
public void test(){
this.goodsDao.save();
}
}
5. 注解AOP通知类型
@Before 前置通知
切面类：
@Aspect
public class GoodsDaoAspect {
@Before(value = "execution(* com.xzh.spring.demo5.GoodsDaoImpl.save(..))")
public void before(){
System.out.println("前置增强");
}
}
@AfterReturning 后置通知
（1）没有返回值
切面类：
@Aspect
public class GoodsDaoAspect {
@AfterReturning(value = "execution(* com.xzh.spring.demo5.GoodsDaoImpl.update(..))")
public void afterReturning(){
System.out.println("后置通知");
}
}
（2）有返回值
切面类：
@Aspect
public class GoodsDaoAspect {
@AfterReturning(value = "execution(* com.xzh.spring.demo5.GoodsDaoImpl.update(..))", returning = "res")
public void afterReturning(Object res){
System.out.println("后置通知" + res);
}
}
@Around 环绕通知
切面类：
@Aspect
public class GoodsDaoAspect {
@Around(value = "execution(* com.xzh.spring.demo5.GoodsDaoImpl.delete(..))")
public Object around(ProceedingJoinPoint joinPoint) throws Throwable {
System.out.println("开启事务");
Object proceed = joinPoint.proceed();
System.out.println("提交事务");
return proceed;
}
}
@AfterThrowing 异常抛出通知
（1）没有获取异常信息
切面类：
@Aspect
public class GoodsDaoAspect {
@AfterThrowing(value = "execution(* com.xzh.spring.demo5.GoodsDaoImpl.find(..))")
public void afterThrowing(){
System.out.println("异常通知");
}
}
（2）获取异常信息
切面类：
@Aspect
public class GoodsDaoAspect {
@AfterThrowing(value = "execution(* com.xzh.spring.demo5.GoodsDaoImpl.find(..))", throwing = "ex")
public void afterThrowing(Throwable ex){
System.out.println("异常通知" + ex.getMessage());
}
}
@After 最终通知
无论代码是否有异常，都会执行
切面类：
@Aspect
public class GoodsDaoAspect {
@After(value = "execution(* com.xzh.spring.demo5.GoodsDaoImpl.find(..))")
public void after(){
System.out.println("最终通知");
}
}
6. 定义多个切入点
一个通知同时定义到多个方法当中
@Aspect
public class GoodsDaoAspect {
@Before(value = "execution(* com.xzh.spring.demo5.GoodsDaoImpl.save(..)) || execution(* com.xzh.spring.demo5.GoodsDaoImpl.delete(..))")
public void before (){
System.out.println("前置通知");
}
}
7. AOP的注解切入点的配置
可以在切面当中定义好切入点，在通知当中直接使用定义好的切入点表达式
@Aspect
public class GoodsDaoAspect {
@Before(value = "GoodsDaoAspect.pointSave() || GoodsDaoAspect.pointDelete()")
public void before (){
System.out.println("前置通知");
}
@Pointcut(value = "execution(* com.xzh.spring.demo5.GoodsDaoImpl.save(..))")
private void pointSave(){} // 写一个空方法，相等于给切点起别名
@Pointcut(value = "execution(* com.xzh.spring.demo5.GoodsDaoImpl.delete(..))")
private void pointDelete(){}
}
8. 当使用接口时与不使用接口内部代理区别
（1）使用接口 JDK动态代理
（2）不使用接口 CGLIB代理
AOP 与 Spring中AOP使用（下）的更多相关文章
- AOP 与 Spring中AOP使用（上）
AOP简介 在软件业,AOP为Aspect Oriented Programming的缩写,意为:面向切面编程, 通过预编译方式和运行期动态代理实现程序功能的统一维护的一种技术. AOP是OOP的延续 ...
- 浅谈spring中AOP以及spring中AOP的注解方式
AOP(Aspect Oriented Programming):AOP的专业术语是"面向切面编程" 什么是面向切面编程,我的理解就是:在不修改源代码的情况下增强功能.好了,下面在 ...
- JAVA高级架构师基础功:Spring中AOP的两种代理方式:动态代理和CGLIB详解
在spring框架中使用了两种代理方式: 1.JDK自带的动态代理. 2.Spring框架自己提供的CGLIB的方式. 这两种也是Spring框架核心AOP的基础. 在详细讲解上述提到的动态代理和CG ...
- Spring中AOP原理，源码学习笔记
一.AOP(面向切面编程):通过预编译和运行期动态代理的方式在不改变代码的情况下给程序动态的添加一些功能.利用AOP可以对应用程序的各个部分进行隔离,在Spring中AOP主要用来分离业务逻辑和系统级 ...
- 【spring 5】AOP：spring中对于AOP的的实现
在前两篇博客中,介绍了AOP实现的基础:静态代理和动态代理,这篇博客介绍spring中AOP的实现. 一.采用Annotation方式 首先引入jar包:aspectjrt.jar && ...
- Spring中AOP简介与切面编程的使用
Spring中AOP简介与使用 什么是AOP? Aspect Oriented Programming(AOP),多译作 "面向切面编程",也就是说,对一段程序,从侧面插入,进行操 ...
- Spring中AOP相关源码解析
前言 在Spring中AOP是我们使用的非常频繁的一个特性.通过AOP我们可以补足一些面向对象编程中不足或难以实现的部分. AOP 前置理论 首先在学习源码之前我们需要了解关于AOP的相关概念如切点切 ...
- Spring中AOP相关的API及源码解析
Spring中AOP相关的API及源码解析 本系列文章: 读源码,我们可以从第一行读起 你知道Spring是怎么解析配置类的吗? 配置类为什么要添加@Configuration注解? 谈谈Spring ...
- 框架源码系列十：Spring AOP（AOP的核心概念回顾、Spring中AOP的用法、Spring AOP 源码学习）
一.AOP的核心概念回顾 https://docs.spring.io/spring/docs/5.1.3.RELEASE/spring-framework-reference/core.html#a ...
随机推荐
- js中的BOM和DOM常用事件方法
笔记: window对象 ● window.innerHeight - 浏览器窗口的内部高度 ● window.innerWidth - 浏览器窗口的内部宽度 ● window.open() - 打开 ...
- 30分钟用Restful ABAP Programming模型开发一个支持增删改查的Fiori应用
2016年时,Jerry曾经写过一系列关于SAP Fiori Smart Template(现在更名为Fiori Elements了)的博客,介绍了所谓的MDD开发方法论 - Metadata Dri ...
- Linux 之 压缩解压缩
Linux中常见的压缩格式 .zip .gz .bz2 .tar.gz tar.bz2 zip zip格式的压缩文件和win ...
- Python基础——__name__变量
转自:https://blog.csdn.net/u011511601/article/details/53504355 Python使用缩进对齐组织代码的执行,所有没有缩进的代码,都会在载入时自动执 ...
- 【DevOps】在Rancher2中启动Docker-Registry仓库服务
准备 拥有Rancher2环境,已经在Rancher2配置Kubernetes集群 拥有域名,拥有SSL证书,可以自行在阿里云申请 启动Docker-Registry仓库服务 第一步:进入集群应用 第 ...
- MySQL运行机制原理&架构
1.MySQL知识普及: MySQL是一个开放源代码的关系数据库管理系统. MySQL架构可以在多种不同场景中应用并发挥良好作用.主要体现在存储引擎的架构上,插件式的存储引擎架构将查询处理和其它的系统 ...
- 【FRDM-K64F学习笔记】使用ARM mbed和Keil MDK下载你的第一个程序
FRDM-K64F开发平台采用MK64FN1M0VLL12微控制器.该控制器包含一个带有浮点单元的ARM Cortex-M4内核.其最高工作频率为120MHz,具有256KB的RAM.1MB闪存以及许 ...
- 【原创】SPFA判负环
[定义与概念] 给定一张有向图,若其中存在一个环的所有权值之和为负数,这个环称为负环. [算法实现] 当然,负环的求解可以暴搜,但是时间复杂度就难以入眼了,我们回到求解单源最短路径算法上面,看看它们能 ...
- Java8 中的 Optional 相关用法
基本方法: ofNullable() 为可能 null 的值创建一个 Optional 实例, 然后可以对该实例遍历/过滤, 判断是否存在,或者为空时执行.. ifPresent(...) 如果值存 ...
- Java 中待总结工具类学习（自定义注解，读取配置，字面List）
1.使用 MessageFormat 格式化文本 int planet = 7; String event = "a disturbance in the Force"; Stri ...