Spring之aop

最新推荐文章于 2024-08-23 15:54:50 发布
最新推荐文章于 2024-08-23 15:54:50 发布
阅读量72 收藏
点赞数
文章标签： servlet java 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_67864917/article/details/126221982
版权

目录

一，AOP的概念(即面向切面编程)

    1，目标(Target)

    2，通知(Advice)

    3   代理(Proxy )

    4   切入点(Pointcut)

    5   适配器(Advisor)

    6   连接点(Joinpoint)

 二：主要通知

1.前置通知

2.后置通知

3.环绕通知

4.异常通知

5.过滤通知

一，AOP的概念(即面向切面编程)


    1，目标(Target)


                被通知(被代理)的对象

    2，通知(Advice)


                在某个特定的连接点上执行的动作，同时Advice也是程序代码的具体实现，例如一个实现日志记录的代码(通知有些书上也称为处理)

    3   代理(Proxy )


                将通知应用到目标对象后创建的对象(代理=目标+通知),只有代理对象才有AOP功能，而AOP的代码是写在通知的方法里面的

    4   切入点(Pointcut)


                多个连接点的集合，定义了通知应该应用到那些连接点。
                 (也将Pointcut理解成一个条件 ，此条件决定了容器在什么情况下将通知和目标组合成代理返回给外部程序)

    5   适配器(Advisor)


                适配器=通知(Advice)+切入点(Pointcut)

    6   连接点(Joinpoint)


                程序执行过程中明确的点，如方法的调用，或者异常的抛出.
 

 二：主要通知

1.前置通知

<!-- 目标对象 -->
	<bean class="com.zking.aop.biz.impl.BookBizImpl" id="bookBiz"></bean>
	<!-- 前置通知 -->
	<bean class="com.zking.aop.advice.MyMethodBeforeAdvice" id="myBefore"></bean>
	<!-- 代理对象=目标+通知 -->
	<bean class="org.springframework.aop.framework.ProxyFactoryBean" id="bookProxy">
		<!-- 目标 -->
		<property name="target" ref="bookBiz"></property>
		<!-- 目标所实现的接口列表 -->
		<property name="proxyInterfaces">
			<list>
				<value>com.zking.aop.biz.BookBiz</value>
			</list>
		</property>
		<!-- 通知:正式调用目标方法的时候，会调用下面指定的通知 -->
		<property name="interceptorNames">
			<list>
				<value>myBefore</value>
			</list>
		</property>
	</bean>

package com.zking.aop.advice;

import java.lang.reflect.Method;
import java.util.Arrays;

import org.springframework.aop.MethodBeforeAdvice;

/**
 * 前置通知
 *	买书、评论前加系统日志
 * @author Administrator
 *
 */
public class MyMethodBeforeAdvice implements MethodBeforeAdvice{

	@Override
	public void before(Method arg0, Object[] arg1, Object arg2) throws Throwable {
//		目标对象的类名
		String clzName = arg2.getClass().getName();
//		当前调用的方法是
		String methodName = arg0.getName();
//		当前调用方法所传递参数
		String args = Arrays.toString(arg1);
		System.out.println("【系统日志】："+clzName+"."+methodName+"被调用,传递的参数为："+args);
	}
	
}


package com.zking.aop.biz;

public interface BookBiz {
	// 购书
	public boolean buy(String userName, String bookName, Double price);

	// 发表书评
	public void comment(String userName, String comments);
}


package com.zking.aop.biz.impl;

import com.zking.aop.biz.BookBiz;
import com.zking.aop.exception.PriceException;

public class BookBizImpl implements BookBiz {

	public BookBizImpl() {
		super();
	}

	public boolean buy(String userName, String bookName, Double price) {
		// 通过控制台的输出方式模拟购书
		if (null == price || price <= 0) {
			throw new PriceException("book price exception");
		}
//		logDao.add->sout("买书相关日志...")
		System.out.println(userName + " buy " + bookName + ", spend " + price);
		return true;
	}

	public void comment(String userName, String comments) {
		// 通过控制台的输出方式模拟发表书评
		System.out.println(userName + " say:" + comments);
	}

}


package com.zking.aop.exception;

public class PriceException extends RuntimeException {

	public PriceException() {
		super();
	}

	public PriceException(String message, Throwable cause, boolean enableSuppression, boolean writableStackTrace) {
		super(message, cause, enableSuppression, writableStackTrace);
	}

	public PriceException(String message, Throwable cause) {
		super(message, cause);
	}

	public PriceException(String message) {
		super(message);
	}

	public PriceException(Throwable cause) {
		super(cause);
	}
	
}


package com.zking.aop.test;

import org.springframework.context.support.ClassPathXmlApplicationContext;

import com.zking.aop.biz.BookBiz;

public class Demo1 {
	@SuppressWarnings("resource")
	public static void main(String[] args) {
		ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext("/spring-context.xml");
//		BookBiz bean = (BookBiz)context.getBean("bookBiz");
		BookBiz bean = (BookBiz)context.getBean("bookProxy");
		bean.buy("nx", "jpm", 6.6d);
		bean.comment("sfd", "asd");
	}
}

2.后置通知

<?xml version="1.0" encoding="UTF-8"?>
<beans default-autowire="byName" xmlns="http://www.springframework.org/schema/beans"
	xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
	xmlns:aop="http://www.springframework.org/schema/aop"
	xmlns:context="http://www.springframework.org/schema/context"
	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-4.3.xsd
		http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-4.3.xsd">

	<!-- IOC的主要作用管理整个项目的javabean，依靠依赖注入、控制反转的特点进行管理 -->
	<bean class="com.zking.biz.impl.UserBizImpl1" id="userBiz"></bean>
	<!-- <bean class="com.zking.biz.impl.UserBizImpl2" id="userBiz"></bean> -->
	<!-- set注入 -->
	<bean class="com.zking.web.UserAction" id="userAction">
		<property name="userBiz" ref="userBiz"></property>
		<property name="age" value="22"></property>
		<property name="name" value="zhangsan"></property>
		<property name="hobby">
			<list>
				<value>篮球</value>
				<value>boy</value>
				<value>篮球</value>
			</list>
		</property>
	</bean>
	<!-- 构造注入 -->
	<bean class="com.zking.web.OrderAction" id="orderAction">
		<property name="userBiz" ref="userBiz"></property>
		<constructor-arg name="name" value="zhangsan"></constructor-arg>
		<constructor-arg name="age" value="22"></constructor-arg>
		<constructor-arg name="hobby">
			<list>
				<value>篮球</value>
				<value>boy</value>
				<value>篮球</value>
			</list>
		</constructor-arg>
	</bean>
	
	<!-- 目标对象 -->
	<bean class="com.zking.aop.biz.impl.BookBizImpl" id="bookBiz"></bean>
	<!-- 前置通知 -->
	<bean class="com.zking.aop.advice.MyMethodBeforeAdvice" id="myBefore"></bean>
	<!-- 后置通知 -->
	<bean class="com.zking.aop.advice.MyAfterReturningAdvice" id="myAfter"></bean>
	<!-- 代理对象=目标+通知 -->
	<bean class="org.springframework.aop.framework.ProxyFactoryBean" id="bookProxy">
		<!-- 目标 -->
		<property name="target" ref="bookBiz"></property>
		<!-- 目标所实现的接口列表 -->
		<property name="proxyInterfaces">
			<list>
				<value>com.zking.aop.biz.BookBiz</value>
			</list>
		</property>
		<!-- 通知:正式调用目标方法的时候，会调用下面指定的通知 -->
		<property name="interceptorNames">
			<list>
				<value>myBefore</value>
				<value>myAfter</value>
			</list>
		</property>
	</bean>
	
</beans>


package com.zking.aop.test;

import org.springframework.context.support.ClassPathXmlApplicationContext;

import com.zking.aop.biz.BookBiz;

public class Demo1 {
	@SuppressWarnings("resource")
	public static void main(String[] args) {
		ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext("/spring-context.xml");
//		BookBiz bean = (BookBiz)context.getBean("bookBiz");
		BookBiz bean = (BookBiz)context.getBean("bookProxy");
		bean.buy("nx", "jpm", 6.6d);
		bean.comment("sfd", "asd");
	}
}


package com.zking.aop.advice;

import java.lang.reflect.Method;
import java.util.Arrays;

import org.springframework.aop.AfterReturningAdvice;

public class MyAfterReturningAdvice implements AfterReturningAdvice{

	@Override
	public void afterReturning(Object arg0, Method arg1, Object[] arg2, Object arg3) throws Throwable {
//		目标对象的类名
		String clzName = arg3.getClass().getName();
//		当前调用的方法是
		String methodName = arg1.getName();
//		当前调用方法所传递参数
		String args = Arrays.toString(arg2);
		System.out.println("【买书返利】："+clzName+"."+methodName+"被调用,传递的参数为："+args+";目标对象方法返回值为："+arg0);
	}

}

3.环绕通知

package com.zking.aop.test;

import org.springframework.context.support.ClassPathXmlApplicationContext;

import com.zking.aop.biz.BookBiz;

public class Demo1 {
	@SuppressWarnings("resource")
	public static void main(String[] args) {
		ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext("/spring-context.xml");
//		BookBiz bean = (BookBiz)context.getBean("bookBiz");
		BookBiz bean = (BookBiz)context.getBean("bookProxy");
		bean.buy("nx", "jpm", 6.6d);
		bean.comment("sfd", "asd");
	}
}


package com.zking.aop.advice;

import java.util.Arrays;

import org.aopalliance.intercept.MethodInvocation;

/**
 * 环绕通知=前置通知+后置通知
 * @author Administrator
 *
 */
public class MethodInterceptor implements org.aopalliance.intercept.MethodInterceptor{

	@Override
	public Object invoke(MethodInvocation arg0) throws Throwable {
//		目标对象的类名
		String clzName = arg0.getThis().getClass().getName();
//		当前调用的方法是
		String methodName = arg0.getMethod().getName();
//		当前调用方法所传递参数
		String args = Arrays.toString(arg0.getArguments());
		System.out.println("【环绕通知】："+clzName+"."+methodName+"被调用,传递的参数为："+args);
//		方法的返回值	执行目标方法	bookBiz.buy(as,jasd,6.6);
		Object rs = arg0.proceed();
		System.out.println("【环绕通知】：目标对象方法返回值为："+rs);
		return rs;
	}

}

 

<?xml version="1.0" encoding="UTF-8"?>
<beans default-autowire="byName" xmlns="http://www.springframework.org/schema/beans"
	xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
	xmlns:aop="http://www.springframework.org/schema/aop"
	xmlns:context="http://www.springframework.org/schema/context"
	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-4.3.xsd
		http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-4.3.xsd">

	<!-- IOC的主要作用管理整个项目的javabean，依靠依赖注入、控制反转的特点进行管理 -->
	<bean class="com.zking.biz.impl.UserBizImpl1" id="userBiz"></bean>
	<!-- <bean class="com.zking.biz.impl.UserBizImpl2" id="userBiz"></bean> -->
	<!-- set注入 -->
	<bean class="com.zking.web.UserAction" id="userAction">
		<property name="userBiz" ref="userBiz"></property>
		<property name="age" value="22"></property>
		<property name="name" value="zhangsan"></property>
		<property name="hobby">
			<list>
				<value>篮球</value>
				<value>boy</value>
				<value>篮球</value>
			</list>
		</property>
	</bean>
	<!-- 构造注入 -->
	<bean class="com.zking.web.OrderAction" id="orderAction">
		<property name="userBiz" ref="userBiz"></property>
		<constructor-arg name="name" value="zhangsan"></constructor-arg>
		<constructor-arg name="age" value="22"></constructor-arg>
		<constructor-arg name="hobby">
			<list>
				<value>篮球</value>
				<value>boy</value>
				<value>篮球</value>
			</list>
		</constructor-arg>
	</bean>
	
	<!-- 目标对象 -->
	<bean class="com.zking.aop.biz.impl.BookBizImpl" id="bookBiz"></bean>
	<!-- 前置通知 -->
	<bean class="com.zking.aop.advice.MyMethodBeforeAdvice" id="myBefore"></bean>
	<!-- 后置通知 -->
	<bean class="com.zking.aop.advice.MyAfterReturningAdvice" id="myAfter"></bean>
	<!-- 环绕通知 -->
	<bean class="com.zking.aop.advice.MethodInterceptor" id="myMethod"></bean>
	<!-- 代理对象=目标+通知 -->
	<bean class="org.springframework.aop.framework.ProxyFactoryBean" id="bookProxy">
		<!-- 目标 -->
		<property name="target" ref="bookBiz"></property>
		<!-- 目标所实现的接口列表 -->
		<property name="proxyInterfaces">
			<list>
				<value>com.zking.aop.biz.BookBiz</value>
			</list>
		</property>
		<!-- 通知:正式调用目标方法的时候，会调用下面指定的通知 -->
		<property name="interceptorNames">
			<list>
				<value>myBefore</value>
				<value>myAfter</value>
				<value>myMethod</value>
			</list>
		</property>
	</bean>
	
</beans>

4.异常通知

package com.zking.aop.test;

import org.springframework.context.support.ClassPathXmlApplicationContext;

import com.zking.aop.biz.BookBiz;

public class Demo1 {
	@SuppressWarnings("resource")
	public static void main(String[] args) {
		ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext("/spring-context.xml");
//		BookBiz bean = (BookBiz)context.getBean("bookBiz");
		BookBiz bean = (BookBiz)context.getBean("bookProxy");
		bean.buy("nx", "jpm", -6.6d);
		bean.comment("sfd", "asd");
	}
}


package com.zking.aop.advice;

import org.springframework.aop.ThrowsAdvice;

import com.zking.aop.exception.PriceException;

/**
 * 关于过滤通知
 * 	相较于前置通知、后置通知、环绕通知有一个非常大的区别
 * 	前面三大通知都需要实现其中的方法
 * 	环绕通知则不需要，但是，它的方法名又是固定的；
 * @author Administrator
 *
 */
public class MyThrowsAdvice implements ThrowsAdvice{
	public void after(PriceException p) {
		System.out.println("【异常通知】：当价格发生异常，那么执行此处代码块！！！");
	}
}

 

<?xml version="1.0" encoding="UTF-8"?>
<beans default-autowire="byName" xmlns="http://www.springframework.org/schema/beans"
	xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
	xmlns:aop="http://www.springframework.org/schema/aop"
	xmlns:context="http://www.springframework.org/schema/context"
	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-4.3.xsd
		http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-4.3.xsd">

	<!-- IOC的主要作用管理整个项目的javabean，依靠依赖注入、控制反转的特点进行管理 -->
	<bean class="com.zking.biz.impl.UserBizImpl1" id="userBiz"></bean>
	<!-- <bean class="com.zking.biz.impl.UserBizImpl2" id="userBiz"></bean> -->
	<!-- set注入 -->
	<bean class="com.zking.web.UserAction" id="userAction">
		<property name="userBiz" ref="userBiz"></property>
		<property name="age" value="22"></property>
		<property name="name" value="zhangsan"></property>
		<property name="hobby">
			<list>
				<value>篮球</value>
				<value>boy</value>
				<value>篮球</value>
			</list>
		</property>
	</bean>
	<!-- 构造注入 -->
	<bean class="com.zking.web.OrderAction" id="orderAction">
		<property name="userBiz" ref="userBiz"></property>
		<constructor-arg name="name" value="zhangsan"></constructor-arg>
		<constructor-arg name="age" value="22"></constructor-arg>
		<constructor-arg name="hobby">
			<list>
				<value>篮球</value>
				<value>boy</value>
				<value>篮球</value>
			</list>
		</constructor-arg>
	</bean>
	
	<!-- 目标对象 -->
	<bean class="com.zking.aop.biz.impl.BookBizImpl" id="bookBiz"></bean>
	<!-- 前置通知 -->
	<bean class="com.zking.aop.advice.MyMethodBeforeAdvice" id="myBefore"></bean>
	<!-- 后置通知 -->
	<bean class="com.zking.aop.advice.MyAfterReturningAdvice" id="myAfter"></bean>
	<!-- 异常通知 -->
	<bean class="com.zking.aop.advice.MyThrowsAdvice" id="myThrows"></bean>
	<!-- 环绕通知 -->
	<bean class="com.zking.aop.advice.MethodInterceptor" id="myMethod"></bean>
	<!-- 代理对象=目标+通知 -->
	<bean class="org.springframework.aop.framework.ProxyFactoryBean" id="bookProxy">
		<!-- 目标 -->
		<property name="target" ref="bookBiz"></property>
		<!-- 目标所实现的接口列表 -->
		<property name="proxyInterfaces">
			<list>
				<value>com.zking.aop.biz.BookBiz</value>
			</list>
		</property>
		<!-- 通知:正式调用目标方法的时候，会调用下面指定的通知 -->
		<property name="interceptorNames">
			<list>
				<value>myBefore</value>
				<value>myAfter</value>
				<value>myMethod</value>
				<value>myThrows</value>
			</list>
		</property>
	</bean>
	
</beans>

5.过滤通知

package com.zking.aop.test;

import org.springframework.context.support.ClassPathXmlApplicationContext;

import com.zking.aop.biz.BookBiz;

public class Demo1 {
	@SuppressWarnings("resource")
	public static void main(String[] args) {
		ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext("/spring-context.xml");
//		BookBiz bean = (BookBiz)context.getBean("bookBiz");
		BookBiz bean = (BookBiz)context.getBean("bookProxy");
		bean.buy("nx", "jpm", 6.6d);
		bean.comment("sfd", "asd");
	}
}

周甘木
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
spring 之aop
03-06
标题中的“Spring 之AOP”指的是在Spring框架中对面向切面编程（Aspect-Oriented Programming，简称AOP）的使用。AOP是软件设计的一种模式，它将关注点分离，使得我们可以独立地处理系统中的交叉关注点，如日志、...
spring之AOP（动态代理）
09-06
在Spring框架中，AOP（面向切面编程）是一种强大的设计模式，它允许开发者将关注点分离，将横切关注点（如日志、事务管理、权限检查等）与核心业务逻辑解耦。AOP的核心概念是切面、通知、连接点、切入点和织入。在...
Spring之AOP的详细讲解
tq02的博客
04-09 3386
本文讲解的是SpringAOP，将切点、切面、通知点，逐步剖析，代码举例，配合理解！
Spring之AOP注解开发
楠黎倾风的博客
11-25 1万+
Spring之AOP注解开发
Spring之AOP日志记录
积跬步，至千里。
10-17 1464
在Java中，可以使用注解和切面技术来实现AOP（Aspect Oriented Programming）。AOP是一种编程范式，它通过将应用程序分解为关注点的模块来提高代码的可维护性和重用性。注解可以用于标记程序元素，例如类、方法和字段，以便切面可以识别和操作这些元素。
细说Spring——AOP详解（AOP概览）
热门推荐
啦啦啦的博客
05-30 53万+
一、对AOP的初印象 首先先给出一段比较专业的术语（来自百度）： 在软件业，AOP为Aspect Oriented Programming的缩写，意为：面向切面编程，通过预编译方 式和运行期动态代理实现程序功能的统一维护的一种技术。AOP是OOP的延续，是软件开发中的一个 热点，也是Spring框架中的一个重要内容，是函数式编程的一种衍生范型。利用AOP可以对业务逻辑 的各个部分进行隔离，从而...
Spring之aop注解实现
qq_47455973的博客
02-28 3719
Spring中的AOP1.什么是AOP2.怎么实现AOP# 2.1AOP相关的注解介绍# 2.2实现AOP的xml配置# 2.3实现AOP# 2.4对相同切入点的公共化# 2.5设置多个增强类的优先级 1.什么是AOP Aop是java的spring框架中的一种特性，aop是面向切面编程的缩写，那什么是面向切面编程呢？ 面向切面编程就是，在不对源码进行修改的情况下对源码所实现的功能进行增强。 举例说明 原本一个程序可以实现用户登入的功能，然后我想在这个功能的基础上，加入一个新的功能，就是对用户等级的判断，按
Spring之AOP入门篇
楠黎倾风的博客
11-15 1万+
spring之AOP入门篇
Spring之AOP适配器模式
波波烤鸭的博客
03-06 8310
  Spring架构中涉及了很多设计模式，本文来介绍下Spring中在AOP实现时Adapter模式的使用。AOP本质上是Java动态代理模式的实现和适配器模式的使用，关于这两种设计模式的具体介绍烦请参考我之前的文章 Java代理模式 Java适配器模式(adapter) 文章目录Spring中适配器模式一、AOP案例1.相关依赖2.创建目标对象3.创建通知4.配置文件5.测试二、适配器应用解...
Spring之AOP简介
weixin_43790613的博客
01-23 4897
文章目录定义AOP 的作用及优势 定义 AOP： 全称是 Aspect Oriented Programming 即： 面向切面编程 简单的说它就是把我们程序重复的代码抽取出来，在需要执行的时候，使用动态代理的技术，在不修改源码的基础上，对我们的已有方法进行增强 AOP 的作用及优势 作用：在程序运行期间，不修改源码对已有方法进行增强。 优势： 减少重复代码 提高开发效率 维护方便 实现方式 使用动态代理技术 ...
Spring之AOP的原理(一)--概述
IT利刃出鞘的博客
11-18 4830
本文介绍Spring中的AOP的原理。
Spring框架之AOP详解
qq_45515347的博客
09-05 1988
Spring AOP 详解，并实现demo
死磕Spring之AOP篇 - Spring AOP两种代理对象的拦截处理（csdn）————程序.pdf
12-05
Spring AOP 是一种面向切面编程的技术，它允许我们在不修改源代码的情况下，对应用程序的特定部分（如方法调用）进行增强。在 Spring 中，AOP 的实现主要依赖于代理模式，有两种代理方式：JDK 动态代理和 CGLIB 动态...
开发多线程程序时，需要注意那些问题
最新发布
OO_SEN的博客
08-23 409
线程安全 竞态条件（Race Condition）：当多个线程同时访问和修改共享资源时，可能会出现竞态条件，导致不确定的行为。需要通过同步机制（如互斥锁、读写锁、原子操作）来保护共享资源。 死锁（Deadlock）：当两个或多个线程相互等待对方释放锁时，程序会陷入死锁状态。避免死锁的一些策略包括：避免嵌套锁、确保加锁顺序一致、使用超时机制等。 活锁（Livelock）：与死锁不同，活锁是指线程不断地尝试获取资源但总是失败，导致无法继续执行。避免频繁重试操作或使用退避算法可以减少活锁的发生。 优先级反转（P
笔记redis
风止的博客
08-22 743
Redis（Remote Dictionary Server）是用C语言开发的一个基于的数据库。
@Transactional中使用线程锁导致了锁失效与解决方案
liuruiaaa的博客
08-23 501
@Transactional中使用线程锁导致了锁失效与解决方案
android apk 加固后的地图加载异常及重新签名
calivnBao的博客
08-20 246
android apk 加固后的地图加载异常及重新签名
如何使用 Java 记录简化 Spring Data 中的数据实体
08-20 608
Java 开发人员一直依赖Spring Data来实现高效的数据访问。但是，随着Java Records的引入，数据实体的管理方式发生了重大变化。在本文中，我们将讨论 Java Records 在 Spring Data 应用程序中的集成。我们将探讨使用 Java 记录创建健壮的数据实体的好处，并提供真实世界的示例来展示它们在 Spring Data 中的潜力。Java 记录的力量：概述J...
Java学习_18_Stream流
qq_41136689的博客
08-23 1006
博客仅记录个人学习进度和一些查缺补漏。学习内容：BV17F411T7Ao流的出现让数据处理从几十行代码缩减到一两行就能实现，简化了很多集合数组的操作。
Spring AOP：聚焦方法拦截
"Spring AOP是Spring框架中的一个重要模块，专注于面向切面编程，它通过提供方法级别的Joinpoint来实现AOP的功能。虽然Spring AOP仅支持方法执行类型的Joinpoint，但这已经足够应对大部分开发场景。" Spring AOP，...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值