给软件行业带来了春天——揭秘Spring究竟是何方神圣（二）

2024-02-17 13:10
文章标签 java 行业 spring 软件 究竟 揭秘 带来 春天 何方神圣

本文主要是介绍给软件行业带来了春天——揭秘Spring究竟是何方神圣（二），希望对大家解决编程问题提供一定的参考价值，需要的开发者们随着小编来一起学习吧！

系列文章目录

给软件行业带来了春天——揭秘Spring究竟是何方神圣（一）
给软件行业带来了春天——揭秘Spring究竟是何方神圣（二）
给软件行业带来了春天——揭秘Spring究竟是何方神圣（三）
给软件行业带来了春天——揭秘Spring究竟是何方神圣（四）
给软件行业带来了春天——揭秘Spring究竟是何方神圣（五）

文章目录

  • 系列文章目录
        • AOP简介
        • AOP底层原理
          • JDK动态代理
          • Cglib代理
        • Aop术语
        • Aop实现

在这里插入图片描述

AOP简介

AOP（Aspect Oriented Programming） 意为：面向切面编程，通过预编译方式和运行期间动态代理实现程序功能的统一维护的一种技术。利用AOP可以对业务逻辑的各个部分进行隔离，从而使得业务逻辑各部分之间的耦合度降低，提高程序的可重用性，同时提高了开发的效率。通俗表示：不通过修改源代码方式，在主干功能中添加新的功能。
eg:登录功能和权限判断可以分离，权限判断的功能的有无不影响登录功能。

image.png

AOP底层原理

AOP：面向切面编程，一种编程思想。

AOP采取横向抽取机制，取代了传统纵向继承体系重复性代码的编写方式（性能监视、事务管理、安全检查、缓存,日志记录等）。

AOP就是要对目标进行代理对象的创建，AOP底层使用动态代理的：JDK动态代理和CGLIB动态代理。

动态代理和静态代理区别？
动态代理：在虚拟机内部，运行的时候，动态生成代理类(运行时生成，runtime生成) ，并不是真正存在的类。
静态代理：存在代理类 （例如：struts2 Action的代理类 ActionProxy）

简单来说：有接口，实现接口的类对象，无接口，继承类，创建子对象。

JDK动态代理

JDK动态代理：基于接口的代理，一定是基于接口，会生成目标对象的接口类型的子对象。

image.png

JDK动态代理的一般步骤如下：
1.创建被代理的接口和类；
2.实现InvocationHandler接口，对目标接口中声明的所有方法进行统一处理；
3.调用Proxy的静态方法，创建代理类并生成相应的代理对象；
实现原理：利用拦截器机制必须实现InvocationHandler接口中的invoke方法实现对我们的目标方法增强。

public class jdkproxy {public  static  void main(String[] args){//创建接口实现类的代理对象Class[] interfaces={UserDao.class};/* proxy实现调用newProxyInstance 方法public static Object newProxyInstance(ClassLoader loader, Class<?>[] interfaces, InvocationHandler h) {}返回 指定接口的代理类的实例，三个参数： 1.类的加载器2.增强方法所在的类，这个类实现的接口，支持多个接口，。3.实现这个接口InvocationHandler，创建代理对象，写增强的部分*/UserDaoImpl userDao=new UserDaoImpl();UserDao userDao1=(UserDao) Proxy.newProxyInstance(jdkproxy.class.getClassLoader(),interfaces,new UserDaoProxy(userDao));int result=userDao1.add(1,2);System.out.println(result);/*也可以使用内部类来实现Proxy.newProxyInstance(jdkproxy.class.getClassLoader(), interfaces, new InvocationHandler() {@Overridepublic Object invoke(Object proxy, Method method, Object[] args) throws Throwable {return null;}})*/}
}
//创建代理对象代码class UserDaoProxy implements InvocationHandler{//创建的是谁的代理对象，将他传递进来//有参构造传递进来private Object object;public UserDaoProxy(Object object){this.object=object;}//增强的逻辑，利用aop实现新增的功能/*invoke三个参数：1、代理对象2、当前的方法3、传入的参数* */@Overridepublic Object invoke(Object proxy, Method method, Object[] args) throws Throwable {//方法之前System.out.println("方法之前执行...."+method.getName()+" :传递的参数..."+ Arrays.toString(args));//被增强的方法执行Object res = method.invoke(object, args);//方法之后System.out.println("方法之后执行...."+object);return res;}}

Cglib代理


Cglib代理：基于类的代理，不需要基于接口，会生成目标对象类型的子对象。
1.Cglib是一个强大的，高性能，高质量的代码生成类库。它可以在运行期扩展JAVA类与实现JAVA接口。其底层实现是通过ASM字节码处理框架来转换字节码并生成新的类。大部分功能实际上是ASM所提供的，Cglib只是封装了ASM，简化了ASM操作，实现了运行期生成新的class。
2.运行时动态的生成一个被代理类的子类（通过ASM字节码处理框架实现），子类重写了被代理类中所有非final的方法。在子类中采用方法拦截的技术拦截所有父类方法的调用，顺势植入横切逻辑。
3.jdk7开始 jdk动态代理效率比cglib要高
image.png


public interface OrderService {/*** 添加数据*/String addOrder(String orderName);
}

public class OrderServiceImpl implements OrderService {
//    @Overridepublic String addOrder(String orderName) {log.info("<orderName:{}>", orderName);return "ok";}
}

@Slf4j
public class MayiktCglibMethodInterceptor implements MethodInterceptor {@Overridepublic Object intercept(Object obj, Method method, Object[] args, MethodProxy proxy) throws Throwable {log.info("<目标方法之前开始执行....>");//  Object result = method.invoke(obj, args);Object result = proxy.invokeSuper(obj, args);log.info("<目标方法之后开始执行....>");return result;}
}

public class Test01 {public static void main(String[] args) {System.setProperty(DebuggingClassWriter.DEBUG_LOCATION_PROPERTY, "D:\\ideaproject\\cglib");MayiktCglibMethodInterceptor mayiktCglibMethodInterceptor = new MayiktCglibMethodInterceptor();Enhancer enhancer = new Enhancer();// 设置代理enhancer.setSuperclass(OrderServiceImpl.class);// 设置cglib 回调类enhancer.setCallback(mayiktCglibMethodInterceptor);// 创建cglib代理类OrderServiceImpl orderServiceImpl = (OrderServiceImpl) enhancer.create();String result = orderServiceImpl.addOrder("mayikt");System.out.println(result);}
}

Aop术语

  1. 连接点（Join point）:连接点表示应用执行过程中能够插入切面的一个点，这个点可以是方法的调用、异常的抛出。在 Spring AOP 中，连接点总是方法的调用。

    类里面的哪些方法可以被增强，这些方法称为连接点

  2. 切点（PointCut）:可以插入增强处理的连接点，实际被真正增强的方法，称为切点

切点表达式：知道对哪个类里面的哪个方法进行增强。

切入点表达式
execution（[权限修饰符][返回类型][类全路径][方法名称][参数列表]）@Pointcut(value = "execution(* aspect.*.add())")
//对于aspect包中所有类中的add()方法增强。

  1. 通知（Advice)/（增强）:真正增强的逻辑部分称为增强（通知）。通知描述了切面何时执行以及如何执行增强处理， 实际增强的业务逻辑。

    通知，实际就是在方法前后执行代码。<br />       通知多种类型：
  • 前置通知
  • 后置通知
  • 环绕通知
  • 异常通知
  • 最终通知（finally）


实例代码：

public class UserProxy {public UserProxy() {}//相同切入点@Pointcut(value = "execution(* aspect.*.add())")public void pointcut(){}//前置通知//@Before注解表示前置通知@Before(value = "pointcut()")public void before(){System.out.println("before 前置通知");}//后置通知（返回值后通知）@AfterReturning(value = "execution(* aspect.*.destory())")public void afterReturning() {System.out.println("afterReturning.........");}//最终通知（不管有无异常都执行）@After(value = "execution(* aspect.*.add())")public void after() {System.out.println("after.........");}//异常通知（）@AfterThrowing(value = "execution(* aspect.*.add())")public void afterThrowing() {System.out.println("afterThrowing.........");}//环绕通知（方法之前和之后都通知）@Around(value = "execution(* aspect.*.add())")public void around(ProceedingJoinPoint proceedingJoinPoint) throws Throwable {System.out.println("环绕之前.........");//被增强的方法执行proceedingJoinPoint.proceed();System.out.println("环绕之后.........");}
}
  1. 切面（Aspect）: 切面是通知和切点的结合，是一个动作过程。 把通知应用到的过程就是切面。
  2. 引入（Introduction）：允许我们向现有的类添加新的方法或者属性。
  3. 织入（Weaving）: 将增强处理添加到目标对象中，并创建一个被增强的代理对象。
Aop实现

AspectJ
AspectJ是一个面向切面的框架，它扩展了Java语言。AspectJ定义了AOP语法，它有一个专门的编译器用来生成遵守Java字节编码规范的Class文件,AspectJ不是Spring组成部分,独立AOP框架,一般把AspectJ和Spring框架一起使用,进行AOP操作.

maven依赖
添加相关maven依赖

<!--AspectJ 开始--><dependency><groupId>org.springframework</groupId><artifactId>spring-aspects</artifactId><version>5.2.5.RELEASE</version></dependency><dependency><groupId>org.aspectj</groupId><artifactId>aspectjtools</artifactId><version>1.9.5</version></dependency><dependency><groupId>aopalliance</groupId><artifactId>aopalliance</artifactId><version>1.0</version></dependency><dependency><groupId>org.aspectj</groupId><artifactId>aspectjweaver</artifactId><version>1.9.0</version></dependency><dependency><groupId>cglib</groupId><artifactId>cglib</artifactId><version>3.3.0</version></dependency><!--AspectJ 结束-->

基于AspectJ实现Aop方式：

  • 基于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/beans http://www.springframework.org/schema/beans/spring-beans.xsdhttp://www.springframework.org/schema/context  http://www.springframework.org/schema/context/spring-context.xsdhttp://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop.xsd
"><!--开启注解扫描--><context:component-scan base-package="aspect"></context:component-scan><!--开启Aspect生成代理对象--><aop:aspectj-autoproxy></aop:aspectj-autoproxy>
</beans>
  • 基于注解方式实现
@Aspect
public class LogAspect {@Pointcut("execution(* com.ctj.service.*.*(..))")public void pointcutName(){}@Before("pointcutName()")public void performance(){System.out.println("Spring AOP");}
}

在多个增强类多同一个方法进行增强，设置增强类优先级
1.在增强类上面添加注解@Order(数字类型值)，数字类型值越小优先级越高

@Component
@Aspect
@Order(2)
public class Username {@Before(value = "execution(* aspect.*.add())")public void before(){System.out.println("执行：");}
}

@Component
@Aspect
@Order(4)
public class User {public User() {System.out.println(" ");}public  void add(){System.out.println("add()");}public void destory(){System.out.println("销毁：");}
}

完全采用注解

@Configuration
@ComponentScan(basePackages = {"config"})
@EnableAspectJAutoProxy(proxyTargetClass = true)
public class ConfigAop {}

在本文中，我们深入探讨了 Spring 框架的核心特性AOP。然而，这只是 Spring 引领软件行业变革的冰山一角。在下一篇文章中，我们将进一步剖析 Spring 的其他特性，在不同应用场景下的实际运用，揭示更多关于其灵活性和强大功能的细节。让我们一同探索 Spring 如何继续塑造着未来软件开发的方向！
敬请期待下一篇文章的精彩内容！

在这里插入图片描述

这篇关于给软件行业带来了春天——揭秘Spring究竟是何方神圣（二）的文章就介绍到这儿，希望我们推荐的文章对编程师们有所帮助！


http://www.chinasem.cn/article/717854。

相关文章

JVM 的类初始化机制

JVM 的类初始化机制

前言 当你在 Java 程序中new对象时，有没有考虑过 JVM 是如何把静态的字节码（byte code）转化为运行时对象的呢，这个问题看似简单，但清楚的同学相信也不会太多，这篇文章首先介绍 JVM 类初始化的机制，然后给出几个易出错的实例来分析，帮助大家更好理解这个知识点。 JVM 将字节码转化为运行时对象分为三个阶段，分别是：loading 、Linking、initialization
阅读更多...
Spring Security 基于表达式的权限控制

Spring Security 基于表达式的权限控制

前言 spring security 3.0已经可以使用spring el表达式来控制授权，允许在表达式中使用复杂的布尔逻辑来控制访问的权限。 常见的表达式 Spring Security可用表达式对象的基类是SecurityExpressionRoot。 表达式描述hasRole([role])用户拥有制定的角色时返回true （Spring security默认会带有ROLE_前缀）,去
阅读更多...
浅析Spring Security认证过程

浅析Spring Security认证过程

类图 为了方便理解Spring Security认证流程，特意画了如下的类图，包含相关的核心认证类 概述 核心验证器 AuthenticationManager 该对象提供了认证方法的入口，接收一个Authentiaton对象作为参数; public interface AuthenticationManager {Authentication authenticate(Authenti
阅读更多...
Spring Security--Architecture Overview

Spring Security--Architecture Overview

1 核心组件 这一节主要介绍一些在Spring Security中常见且核心的Java类，它们之间的依赖，构建起了整个框架。想要理解整个架构，最起码得对这些类眼熟。 1.1 SecurityContextHolder SecurityContextHolder用于存储安全上下文（security context）的信息。当前操作的用户是谁，该用户是否已经被认证，他拥有哪些角色权限…这些都被保
阅读更多...
Spring Security基于数据库验证流程详解

Spring Security基于数据库验证流程详解

Spring Security 校验流程图 相关解释说明（认真看哦） AbstractAuthenticationProcessingFilter 抽象类 /*** 调用 #requiresAuthentication(HttpServletRequest, HttpServletResponse) 决定是否需要进行验证操作。* 如果需要验证，则会调用 #attemptAuthentica
阅读更多...
Spring Security 从入门到进阶系列教程

Spring Security 从入门到进阶系列教程

Spring Security 入门系列 《保护 Web 应用的安全》 《Spring-Security-入门（一）：登录与退出》 《Spring-Security-入门（二）：基于数据库验证》 《Spring-Security-入门（三）：密码加密》 《Spring-Security-入门（四）：自定义-Filter》 《Spring-Security-入门（五）：在 Sprin
阅读更多...
Java架构师知识体认识

Java架构师知识体认识

源码分析 常用设计模式 Proxy代理模式Factory工厂模式Singleton单例模式Delegate委派模式Strategy策略模式Prototype原型模式Template模板模式 Spring5 beans 接口实例化代理Bean操作 Context Ioc容器设计原理及高级特性Aop设计原理Factorybean与Beanfactory Transaction 声明式事物
阅读更多...
大模型研发全揭秘：客服工单数据标注的完整攻略

大模型研发全揭秘：客服工单数据标注的完整攻略

在人工智能（AI）领域，数据标注是模型训练过程中至关重要的一步。无论你是新手还是有经验的从业者，掌握数据标注的技术细节和常见问题的解决方案都能为你的AI项目增添不少价值。在电信运营商的客服系统中，工单数据是客户问题和解决方案的重要记录。通过对这些工单数据进行有效标注，不仅能够帮助提升客服自动化系统的智能化水平，还能优化客户服务流程，提高客户满意度。本文将详细介绍如何在电信运营商客服工单的背景下进行
阅读更多...
Java进阶13讲__第12讲_1/2

Java进阶13讲__第12讲_1/2

多线程、线程池 1.  线程概念 1.1  什么是线程 1.2  线程的好处 2.   创建线程的三种方式 注意事项 2.1  继承Thread类 2.1.1 认识  2.1.2  编码实现  package cn.hdc.oop10.Thread;import org.slf4j.Logger;import org.slf4j.LoggerFactory
阅读更多...
JAVA智听未来一站式有声阅读平台听书系统小程序源码

JAVA智听未来一站式有声阅读平台听书系统小程序源码

智听未来，一站式有声阅读平台听书系统 🌟&nbsp;开篇：遇见未来，从“智听”开始 在这个快节奏的时代，你是否渴望在忙碌的间隙，找到一片属于自己的宁静角落？是否梦想着能随时随地，沉浸在知识的海洋，或是故事的奇幻世界里？今天，就让我带你一起探索“智听未来”——这一站式有声阅读平台听书系统，它正悄悄改变着我们的阅读方式，让未来触手可及！ 📚&nbsp;第一站：海量资源，应有尽有 走进“智听
阅读更多...

Copyright China编程 23002807@qq.com

沪ICP备2023033072号-2