当前位置： 首页 > news >正文

网站服务器建设费用360收录入口

news 2025/7/4 20:25:20
网站服务器建设费用,360收录入口,海口cms模板建站,网站网页设计工作内容个人简介：Java领域新星创作者；阿里云技术博主、星级博主、专家博主；正在Java学习的路上摸爬滚打，记录学习的过程~ 个人主页：.29.的博客 学习社区：进去逛一逛~ AOP - 面向切面编程一、简述AOP二、AOP底层原理…

在这里插入图片描述

个人简介：Java领域新星创作者；阿里云技术博主、星级博主、专家博主；正在Java学习的路上摸爬滚打，记录学习的过程~
个人主页：.29.的博客
学习社区：进去逛一逛~

在这里插入图片描述

AOP - 面向切面编程

  • 一、简述AOP
  • 二、AOP底层原理
  • 三、实现动态代理（案例）
  • 四、AOP术语
  • 五、AOP的注解方式实现



一、简述AOP

AOP —— 面向切面编程，通过预编译方式和运行期间动态代理实现程序功能的统一维护的一种技术。

是Spring框架中的一个重要内容。利用AOP可以对业务逻辑的各个部分进行隔离，从而使得业务逻辑各部分之间的耦合度降低，提高程序的可重用性，同时提高了开发的效率。

AOP的作用：

  • 简化代码：把方法中固定位置的重复的代码抽取出来，让被抽取的方法更专注于自己的核心功能，提高内聚性。

  • 代码增强：把特定的功能封装到切面类中，看哪里有需要，就往上套，被套用了切面逻辑的方法就被切面给增强了。



二、AOP底层原理

AOP面向切面编程，在底层使用动态代理实现，其中分为两种情况：

  • 有接口时，使用JDK动态代理
  • 无接口时，使用CGLIB动态代理

JDK动态代理：创建接口实现类代理对象，增强类的方法；
CGLIB动态代理：创建子类的代理对象，增强类的方法；



三、实现动态代理（案例）

使用的相关Maven依赖：

<dependencies><!--spring context依赖--><!--当你引入Spring Context依赖之后，表示将Spring的基础依赖引入了--><dependency><groupId>org.springframework</groupId><artifactId>spring-context</artifactId><version>5.2.6.RELEASE</version></dependency><!--spring aop依赖--><dependency><groupId>org.springframework</groupId><artifactId>spring-aop</artifactId><version>5.2.6.RELEASE</version></dependency><!--spring aspects依赖--><dependency><groupId>org.springframework</groupId><artifactId>spring-aspects</artifactId><version>5.2.6.RELEASE</version></dependency><!--junit5测试--><dependency><groupId>org.junit.jupiter</groupId><artifactId>junit-jupiter-api</artifactId><version>5.3.1</version></dependency></dependencies>

① 声明计算器接口Calculator，包含加减乘除的抽象方法：

/*** @author .29.* @create 2023-02-04 15:01*/
public interface Calculator {int add(int i, int j);int sub(int i, int j);int mul(int i, int j);int div(int i, int j);
}

② 创建接口实现类，实现加减乘除等方法：

import org.springframework.stereotype.Component;/*** @author .29.* @create 2023-02-04 15:02*///简单功能的实现类
@Component
public class CalculatorImpl implements Calculator {@Overridepublic int add(int i, int j) {int result = i + j;System.out.println("方法内部 result = " + result);return result;}@Overridepublic int sub(int i, int j) {int result = i - j;System.out.println("方法内部 result = " + result);return result;}@Overridepublic int mul(int i, int j) {int result = i * j;System.out.println("方法内部 result = " + result);return result;}@Overridepublic int div(int i, int j) {int result = i / j;System.out.println("方法内部 result = " + result);return result;}
}

③ 编写被代理对象的工厂类：

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
import java.util.Arrays;/*** @author .29.* @create 2023-02-04 22:05*/
public class ProxyFactory {//目标对象private Object target;public ProxyFactory(Object target){this.target = target;}//返回代理对象public Object getProxy(){//动态代理返回对象//调用Proxy类中的newProxyInstance(),获取动态代理对象/** newProxyInstance()中需要传入三个参数* ① ClassLoader：加载动态生成代理类的 类加载器* ② Class[] interfaces： 目标对象实现的所有接口* ③ InvocationHandler: 设置代理对象实现目标对象方法的过程* */ClassLoader classLoader = target.getClass().getClassLoader();Class<?>[] interfaces = target.getClass().getInterfaces();InvocationHandler invocationHandler = new InvocationHandler(){//参数一：代理对象//参数二：需要重写目标对象的方法//参数三：method方法（参数二）中的参数@Overridepublic Object invoke(Object proxy, Method method, Object[] args) throws Throwable {//方法调用前输出的日志System.out.println("[动态代理][日志]"+method.getName()+",参数："+ Arrays.toString(args));//调用目标方法Object result = method.invoke(target, args);//方法调用后输出的日志System.out.println("[动态代理][日志]"+method.getName()+",结果："+ result);return result;}};//调用Proxy类中的newProxyInstance(),获取动态代理对象return Proxy.newProxyInstance(classLoader,interfaces,invocationHandler);}
}

④ 测试：

/*** @author .29.* @create 2023-02-04 22:24*/
public class TestCalculator {public static void main(String[] args) {//创建代理对象ProxyFactory proxyFactory = new ProxyFactory(new CalculatorImpl());//通过代理对象获取目标对象Calculator proxy = (Calculator) proxyFactory.getProxy();//调用目标对象方法proxy.add(1,1);System.out.println();proxy.div(1,1);System.out.println();proxy.mul(1,1);System.out.println();proxy.sub(1,1);System.out.println();}
}

在这里插入图片描述



四、AOP术语

1.横切关注点：
分散在每个各个模块中解决同一样的问题，如用户验证、日志管理、事务处理、数据缓存都属于横切关注点。

从每个方法中抽取出来的同一类非核心业务。在同一个项目中，我们可以使用多个横切关注点对相关方法进行多个不同方面的增强。

这个概念不是语法层面的，而是根据附加功能的逻辑上的需要：有十个附加功能，就有十个横切关注点。

2.通知：
每一个横切关注点上要做的事情都需要写一个方法来实现，这样的方法就叫通知方法。

  • 前置通知：使用@Before注解标识，在被代理的目标方法前执行
  • 返回通知：使用@AfterReturning注解标识，在被代理的目标方法成功结束后执行（寿终正寝）
  • 异常通知：使用@AfterThrowing注解标识，在被代理的目标方法异常结束后执行（死于非命）
  • 后置通知：使用@After注解标识，在被代理的目标方法最终结束后执行（盖棺定论）
  • 环绕通知：使用@Around注解标识，使用try…catch…finally结构围绕整个被代理的目标方法，包括上面四种通知对应的所有位置

各种通知的执行顺序：

  • Spring版本5.3.x以前：
    • 前置通知
    • 目标操作
    • 后置通知
    • 返回通知或异常通知
  • Spring版本5.3.x以后：
    • 前置通知
    • 目标操作
    • 返回通知或异常通知
    • 后置通知

3.切面：
即：封装通知方法的类。

4.目标：
即：被代理的目标对象。

5.代理：
向目标对象应用通知之后创建的代理对象。

6.连接点：
这也是一个纯逻辑概念，不是语法定义的。

把方法排成一排，每一个横切位置看成x轴方向，把方法从上到下执行的顺序看成y轴，x轴和y轴的交叉点就是连接点。通俗说，就是spring允许你使用通知的地方

7.切入点：
定位连接点的方式。

每个类的方法中都包含多个连接点，所以连接点是类中客观存在的事物（从逻辑上来说）。

如果把连接点看作数据库中的记录，那么切入点就是查询记录的 SQL 语句。

Spring 的 AOP 技术可以通过切入点定位到特定的连接点。通俗说，要实际去增强的方法

切点通过 org.springframework.aop.Pointcut 接口进行描述，它使用类和方法作为连接点的查询条件。



五、AOP的注解方式实现

须知：
切入点表达式语法：
execution(权限修饰符 增强方法返回类型 增强方法所在类全路径.方法名称(方法参数))

在这里插入图片描述


1.导入Maven依赖：

<dependencies><!--spring context依赖--><!--当你引入Spring Context依赖之后，表示将Spring的基础依赖引入了--><dependency><groupId>org.springframework</groupId><artifactId>spring-context</artifactId><version>5.2.6.RELEASE</version></dependency><!--spring aop依赖--><dependency><groupId>org.springframework</groupId><artifactId>spring-aop</artifactId><version>5.2.6.RELEASE</version></dependency><!--spring aspects依赖--><dependency><groupId>org.springframework</groupId><artifactId>spring-aspects</artifactId><version>5.2.6.RELEASE</version></dependency><!--junit5测试--><dependency><groupId>org.junit.jupiter</groupId><artifactId>junit-jupiter-api</artifactId><version>5.3.1</version></dependency></dependencies>

2.准备被代理的 接口+实现类：

/*** @author .29.* @create 2023-02-04 15:01*/public interface Calculator {int add(int i, int j);int sub(int i, int j);int mul(int i, int j);int div(int i, int j);
}
import org.springframework.stereotype.Component;/*** @author .29.* @create 2023-02-04 15:02*///简单功能的实现类
@Component
public class CalculatorImpl implements Calculator {@Overridepublic int add(int i, int j) {int result = i + j;System.out.println("方法内部 result = " + result);return result;}@Overridepublic int sub(int i, int j) {int result = i - j;System.out.println("方法内部 result = " + result);return result;}@Overridepublic int mul(int i, int j) {int result = i * j;System.out.println("方法内部 result = " + result);return result;}@Overridepublic int div(int i, int j) {int result = i / j;System.out.println("方法内部 result = " + result);return result;}
}

※ 3.创建并配置切面类：

import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.*;
import org.springframework.stereotype.Component;import java.util.Arrays;/*** @author .29.* @create 2023-02-04 22:47*/
//切面类
//@Aspect代表这是一个切面类
//@Component代表将此类交给Spring处理，能够放入IOC容器中去
@Aspect
@Component
public class LogAspect {//设置切入点 和 通知类型//切入点表达式：execution(权限修饰符 增强方法返回类型 增强方法所在类全路径.方法名称(方法参数))//重用切入点表达式：使用@Pointcut注解，设置需要重复使用的切入点表达式@Pointcut(value = "execution(public int com.haojin.spring.aop.annoaop.CalculatorImpl.*(..))")public void pointCut(){}//之后，在使用通知时，将切入点表达式用 方法名 替换，即pointCut()（同一个切面）//若在不同的切面，需要加上重用切入点表达式方法的全类名：com.haojin.spring.aop.annoaop.LogAspect.pointCut()（不同的切面）//通知类型：// @Before("切入点表达式配置切入点") 前置@Before(value = "pointCut()")   //重用切入点表达式，使用方法名替换public void beforeMethod(JoinPoint joinPoint){String name = joinPoint.getSignature().getName();//获取增强方法的名字Object[] args = joinPoint.getArgs();             //获取增强方法的参数数组System.out.println("Logger-->前置通知，增强方法为："+name+",参数："+ Arrays.toString(args));}// @AfterReturning() 返回//返回通知 可以获取到返回值，在切入表达式中增加返回值属性:returning = ""@AfterReturning(value = "pointCut()",returning = "result")//增强方法中需要添加 返回值参数result，参数名与切入点表达式保持一致（result）public void afterReturningMethod(JoinPoint joinPoint,Object result){//可以存在参数JoinPoint，以此来获取信息String name = joinPoint.getSignature().getName();//获取增强方法的名字System.out.println("Logger-->返回通知，增强方法为："+name+"，返回结果："+result);}// @AfterThrowing() 异常//目标方法出现异常时，此通知会执行，在切入表达式中增加属性：@AfterThrowing(value = "pointCut()",throwing = "exception")//增加 Throwable类型参数，参数名必须与切入点表达式保持一致（exception）public void aAfterThrowingMethod(JoinPoint joinPoint,Throwable exception){//可以存在参数JoinPoint，以此来获取信息String name = joinPoint.getSignature().getName();//获取增强方法的名字System.out.println("Logger-->异常通知，增强方法为："+name+"异常信息："+exception);}// @After() 后置@After(value = "execution(* com.haojin.spring.aop.annoaop.CalculatorImpl.*(..))")public void afterMethod(JoinPoint joinPoint){//可以存在参数JoinPoint，以此来获取信息String name = joinPoint.getSignature().getName();//获取增强方法的名字System.out.println("Logger-->后置通知，增强方法为："+name);}// @Around() 环绕通知，可以通过try-catch-finally,使得增强方法在所有阶段执行（增强方法可设置返回值）@Around("execution(public int com.haojin.spring.aop.annoaop.CalculatorImpl.*(..))")//可设置 ProceedingJoinPoint属性参数,以此调用增强方法(JoinPoint的子接口，JoinPoint没有调用目标方法的功能)public Object aroundMethod(ProceedingJoinPoint joinPoint){String name = joinPoint.getSignature().getName();//通过ProceedingJoinPoint参数获取增强方法名Object[] args = joinPoint.getArgs();             //获取增强方法参数数组String argStr = Arrays.toString(args);           //参数数组转字符串Object result = null;try{System.out.println("环绕通知 == 增强方法执行前执行");//通过ProceedingJoinPoint类型参数调用增强方法result = joinPoint.proceed();System.out.println("环绕通知 = 增强方法返回值之后执行");}catch(Throwable throwable){//捕捉Throwable类型异常throwable.printStackTrace();System.out.println("环绕通知 = 增强方法异常时执行");}finally {System.out.println("环绕方法 = 增强方法执行完毕执行");}return result;}

切面优先级：

切面的优先级控制切面的 内外嵌套 顺序
外层切面：优先级高
内层切面：优先级低

…
可使用@Order()注解设置优先级
@Order(较小的数) 优先级较高
@Order(较大的数) 优先级较低


4.配置Spring配置文件（这里命名为 bean.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:context="http://www.springframework.org/schema/context"xmlns:aop="http://www.springframework.org/schema/aop"xsi:schemaLocation="http://www.springframework.org/schema/beanshttp://www.springframework.org/schema/beans/spring-beans.xsdhttp://www.springframework.org/schema/contexthttp://www.springframework.org/schema/context/spring-context.xsdhttp://www.springframework.org/schema/aophttp://www.springframework.org/schema/aop/spring-aop.xsd"><!--基于注解的AOP的实现：1、将目标对象和切面交给IOC容器管理（注解+扫描）2、开启AspectJ的自动代理，为目标对象自动生成代理3、将切面类通过注解@Aspect标识--><context:component-scan base-package="com.haojin.spring.aop.annoaop"></context:component-scan><!--开启AspectJ的自动代理--><aop:aspectj-autoproxy /></beans>

5.测试：

import com.haojin.spring.aop.annoaop.Calculator;
import org.junit.jupiter.api.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;/*** @author .29.* @create 2023-02-06 9:34*/
public class TestAop {//以实现类中的加法功能为例@Testpublic void testAdd(){ApplicationContext context = new ClassPathXmlApplicationContext("bean.xml");Calculator bean = context.getBean(Calculator.class);bean.add(3,13);}
}

在这里插入图片描述

http://www.dinnco.com/news/20995.html

相关文章：

  • 网站改造夸克搜索
  • 速效成交型网站中国突然宣布一重磅消息
  • 新建网站求友链平台网站优化与seo
  • 免费响应式网站建设360指数查询工具
  • 专业网站推广引流百度游戏排行榜风云榜
  • 广告公司资质最好的关键词排名优化软件
  • 怎么做网站加载动画产品推广计划书怎么写
  • 老外做的汉语网站百度企业
  • 独立网站做跨境电商可以行吗灰色行业推广
  • 游戏币网站建设今日全国最新疫情通报
  • 网上发布信息的网站怎么做的百度搜索电话
  • 怎么知道哪家公司网站做的好网络服务网络推广
  • 深圳效果好的免费网站建设推广方式营销方案
  • 天元建设集团有限公司财务部电话西安seo代理
  • 企业如何做网站推广正规的推文平台
  • 电商网站制作设计推广手段
  • wordpress建站 防攻击福州网seo
  • 建一个网站首先要怎么做进入百度官网
  • ui设计培训哪家好汕头seo管理
  • 做ppt找图片的网站有哪些seo企业优化顾问
  • wordpress feedseo常规优化
  • 网站策划书格式及范文百度发布
  • 网页设计软件html优化系统的软件
  • 贸易网站建设公司上海seo招聘
  • 上海浦东做网站公司网店代运营
  • 做网站的5要素seo的基本步骤是什么
  • 360老是提示危险网站百度加盟
  • 怎么做动态网站谷歌seo工具
  • 滚动网站模版百度搜索排名购买
  • 镇平建设局网站百度网站排名优化价格