Spring AOP使用

最新推荐文章于 2022-03-17 14:55:51 发布
最新推荐文章于 2022-03-17 14:55:51 发布
阅读量408 收藏
点赞数 1
分类专栏： Java 文章标签： aop Aspect AspectJ 切面 proxy
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/lydms/article/details/118861278
版权

文章目录

一、简介

AOP全程是Aspect—Oriented—Programming，面向切面编程。AOP采用横向抽取机制，将分散在各个方法中的重复代码抽取出来，然后在程序编译或运行时，再将这些提取出来的代码应用到需要执行的地方。

  使用AOP编程，可以使开发人员专心于核心业务，而不用过多的关注于其他业务逻辑的是实现，不但提高了开发效率，而且增强了代码的可维护性。

  目前最流行的AOP框架有两个，分别是Spring AOP和AspectJ。其中：Spring AOP采用纯Java实现，不需要专门的编译过程和类加载器，在运行期间通过代理方式向目标类织入增强的代码。AspectJ是一个基于Java语言的AOP框架，从Spring 2.0开始，AspectJ扩展了Java语言，扩展了一个专门的编译器，在编译时提供横向代码的织入。

二、重点解析

1、代理分类

  • Pointcut：全局切入点
  • Before：前置通知
  • After-returning：后置通知
  • Around：环绕通知
  • After-throwing：异常通知
  • After：最终通知
  • Declare-parents：引介通知

2、切入点位置配置(expression)

	// 定义切入点表达式
	@Pointcut("execution(* com.lydms.jdk.*.*(..))")
private void myPointCut(){}
  • 第1个*：表示返回类型，*****表示任意返回类型。
  • com.lydms.jdk：表示需要拦截的包名。
  • 第2个*：表示类名，*****表示所有类。
  • 第3个*：表示方法名，*****表示所有方法。
  • (…)：表示方法的参数，”…“表示任意参数。
  • 第一个*与包名之间有空格。

3、配置通知

属性名称描述
pointcut该属性用于指定一个切入点表达式，Spring将在匹配表达式的连接点时织入该通知。
pointcut-ref该属性指定一个已经存在的切入点名称。通常pointcut和pointcut-ref两个属性只需要其中之一。
method该属性指定一个方法名。指定将切面Bean中的该方法转换为增强处理。
throwing该属性只对<after-throwing>元素有效，它用于指定一个形参名，异常通知方法可以通过该形参访问目标方法所抛出的异常。
returning该属性只对<after-returning>元素有效。它用于指定一个形参名，后置通知方法可以通过该形参访问目标方法的返回值。

案例一：表示任意方法的任意类任意参数都走切面。

	@Pointcut("execution(* com.lydms.jdk.*.*(..))")
	private void myPointCut(){
  }

案例二：public修饰符，在upload类下的。方法走切面。

    @Pointcut("execution(public * com.lydms.controller.upload.*(..))")
    public void webLog() {
    }

二、动态代理

  • Sring AOP中的代理。可以是JDK动态代理，也可以是CGLIB代理。

  • JDK动态代理实现很简单，但是有一定局限性—使用动态代理的对象必须实现一个或多个接口。假如没有实现的，则使用CGLIB代理。

1、JDK动态代理

JDK动态代理通过java.lang.reflect.proxy来实现。可以调用Proxy类的newProxyInstance( )方法来创建代理对象。对于使用业务接口的类，Spring 默认使用JDK动态代理来实现AOP。

1)、UserDao接口

public interface UserDao {
	public void addUser();
	public void deleteUser();
}

2)、UserDaoImpl实现类

import org.springframework.stereotype.Repository;

// 目标类
@Repository("userDao")
public class UserDaoImpl implements UserDao {
	public void addUser() {
//		int i = 10/0;
		System.out.println("添加用户");
	}
	public void deleteUser() {
		System.out.println("删除用户");
	}
}

3)、代理实现类

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
import com.lydms.aspect.MyAspect;
/**
 * JDK代理类
 */
public class JdkProxy implements InvocationHandler{
	// 声明目标类接口
	private UserDao userDao;
	// 创建代理方法
	public  Object createProxy(UserDao userDao) {
		this.userDao = userDao;
		// 1.类加载器
		ClassLoader classLoader = JdkProxy.class.getClassLoader();
		// 2.被代理对象实现的所有接口
		Class[] clazz = userDao.getClass().getInterfaces();
		// 3.使用代理类，进行增强，返回的是代理后的对象
		return  Proxy.newProxyInstance(classLoader,clazz,this);
	}
	/*
	 * 所有动态代理类的方法调用，都会交由invoke()方法去处理
	 * proxy 被代理后的对象 
	 * method 将要被执行的方法信息（反射） 
	 * args 执行方法时需要的参数
	 */
	@Override
	public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
		// 声明切面
		MyAspect myAspect = new MyAspect();
		// 前增强
		myAspect.check_Permissions();
		// 在目标类上调用方法，并传入参数
		Object obj = method.invoke(userDao, args);
		// 后增强
		myAspect.log();
		return obj;
	}
}

4)、测试类

public class JdkTest{
	public static void main(String[] args) {
		// 创建代理对象
		JdkProxy jdkProxy = new JdkProxy();
         // 创建目标对象
		UserDao userDao= new UserDaoImpl();
		// 从代理对象中获取增强后的目标对象
		UserDao userDao1 = (UserDao) jdkProxy.createProxy(userDao);
		// 执行方法
		userDao1.addUser();
		userDao1.deleteUser();
	}
}

执行结果：

在这里插入图片描述

2、CGLIB代理

是一个高性能的开源的代码生成包，采用非常底层字节码技术，对指定的目标类生成子类，并对子类进行加强。

1)、UserDao.java

//目标类
public class UserDao {
	public void addUser() {
		System.out.println("添加用户");
	}
	public void deleteUser() {
		System.out.println("删除用户");
	}
}

2)、代理类

import java.lang.reflect.Method;
import org.springframework.cglib.proxy.Enhancer;
import org.springframework.cglib.proxy.MethodInterceptor;
import org.springframework.cglib.proxy.MethodProxy;
import com.lydms.aspect.MyAspect;
// 代理类
public class CglibProxy implements MethodInterceptor{
    // 代理方法
	public  Object createProxy(Object target) {
		// 创建一个动态类对象
		Enhancer enhancer = new Enhancer();
		// 确定需要增强的类，设置其父类
		enhancer.setSuperclass(target.getClass());
		// 添加回调函数
		enhancer.setCallback(this);
		// 返回创建的代理类
		return enhancer.create();
	}
	/**
	 * proxy CGlib根据指定父类生成的代理对象
	 * method 拦截的方法
	 * args 拦截方法的参数数组
	 * methodProxy 方法的代理对象，用于执行父类的方法 
	 */
	@Override
	public Object intercept(Object proxy, Method method, Object[] args, 
            					 MethodProxy methodProxy) throws Throwable {
         // 创建切面类对象
		MyAspect myAspect = new MyAspect();
		// 前增强
		myAspect.check_Permissions();
		// 目标方法执行
		Object obj = methodProxy.invokeSuper(proxy, args);
		// 后增强
		myAspect.log();	
		return obj;
	}
}

3)、测试类

// 测试类
public class CglibTest {
	public static void main(String[] args) {
		// 创建代理对象
		CglibProxy cglibProxy = new CglibProxy();
         	// 创建目标对象
		UserDao userDao = new UserDao();
         // 获取增强后的目标对象
		UserDao userDao1 = (UserDao)cglibProxy.createProxy(userDao);
		// 执行方法
		userDao1.addUser();
		userDao1.deleteUser();
	}
}

执行结果:
在这里插入图片描述

四、AspectJ开发

1、基于XML的声明式AspectJ

1) 简介

2) 切面类

import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.ProceedingJoinPoint;
/**
 *切面类，在此类中编写通知
 */
public class MyAspect {
	// 前置通知
	public void myBefore(JoinPoint joinPoint) {
		System.out.print("前置通知 ：模拟执行权限检查...,");
		System.out.print("目标类是："+joinPoint.getTarget() );
		System.out.println(",被织入增强处理的目标方法为："
                            +joinPoint.getSignature().getName());
	}
	// 后置通知
	public void myAfterReturning(JoinPoint joinPoint) {
		System.out.print("后置通知：模拟记录日志...," );
		System.out.println("被织入增强处理的目标方法为："
                          + joinPoint.getSignature().getName());
	}
	/**
	 * 环绕通知
	 * ProceedingJoinPoint 是JoinPoint子接口，表示可以执行目标方法
	 * 1.必须是Object类型的返回值
	 * 2.必须接收一个参数，类型为ProceedingJoinPoint
	 * 3.必须throws Throwable
	 */
	public Object myAround(ProceedingJoinPoint proceedingJoinPoint) 
             throws Throwable {
		// 开始
		System.out.println("环绕开始：执行目标方法之前，模拟开启事务...");
		// 执行当前目标方法
		Object obj = proceedingJoinPoint.proceed();
		// 结束
		System.out.println("环绕结束：执行目标方法之后，模拟关闭事务...");
		return obj;
	}
	// 异常通知
	public void myAfterThrowing(JoinPoint joinPoint, Throwable e) {
		System.out.println("异常通知：" + "出错了" + e.getMessage());
	}
	// 最终通知
	public void myAfter() {
		System.out.println("最终通知：模拟方法结束后的释放资源...");
	}
}

3) 注解

<?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-4.3.xsd
        http://www.springframework.org/schema/aop 
        http://www.springframework.org/schema/aop/spring-aop-4.3.xsd">
	<!-- 1 目标类 -->
	<bean id="userDao" class="com.lydms.jdk.UserDaoImpl" />
	<!-- 2 切面 -->
	<bean id="myAspect" class="com.lydms.aspectj.xml.MyAspect" />
	<!-- 3 aop编程 -->
	<aop:config>
        <!-- 配置切面 -->
		<aop:aspect ref="myAspect">
		  <!-- 3.1 配置切入点，通知最后增强哪些方法 -->
		  <aop:pointcut expression="execution(* com.lydms.jdk.*.*(..))"
				                                      id="myPointCut" />
			<!-- 3.2 关联通知Advice和切入点pointCut -->
			<!-- 3.2.1 前置通知 -->
			<aop:before method="myBefore" pointcut-ref="myPointCut" />
			<!-- 3.2.2 后置通知,在方法返回之后执行，就可以获得返回值
			 returning属性：用于设置后置通知的第二个参数的名称,类型是Object -->
			<aop:after-returning method="myAfterReturning"
				pointcut-ref="myPointCut" returning="returnVal" />
			<!-- 3.2.3 环绕通知 -->
			<aop:around method="myAround" pointcut-ref="myPointCut" />
			<!-- 3.2.4 抛出通知：用于处理程序发生异常-->
			<!-- * 注意：如果程序没有异常，将不会执行增强 -->
			<!-- * throwing属性：用于设置通知第二个参数的名称，类型Throwable -->
			<aop:after-throwing method="myAfterThrowing"
				pointcut-ref="myPointCut" throwing="e" />
			<!-- 3.2.5 最终通知：无论程序发生任何事情，都将执行 -->
			<aop:after method="myAfter" pointcut-ref="myPointCut" />
		</aop:aspect>
	</aop:config>
</beans>

4) 测试类

import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
import com.lydms.jdk.UserDao;
// 测试类
public class TestXmlAspectj {
	public static void main(String args[]) {
		String xmlPath = 
                         "com/lydms/aspectj/xml/applicationContext.xml";
		ApplicationContext applicationContext = 
                          new ClassPathXmlApplicationContext(xmlPath);
		// 1 从spring容器获得内容
		UserDao userDao = (UserDao) applicationContext.getBean("userDao");
		// 2 执行方法
		userDao.addUser();
	}
}

2、基于注解的声明式AspectJ

1）注解及其描述：

注解名称描述
@Aspect用于定义一个切面。
@Pointcut用于定义切入点表达式。在使用时，还需要定义方法签名(包含名字和任意参数)，来表示切入点名称。
@Before用于定义前置通知。相当于BeforeAdvice。通常指定一个value值，用来指定切入点表达式。
@AfterReturning用于定义后置通知。相当于AfterReturningAdvice。
@Around用于定义环绕通知。相当于MethodInterceptor。
@AfterThrowing用于定义异常通知来处理程序中未处理的异常。相当于ThrowAdvice。
@After用于定义最终final通知。无论是否异常，都会执行。
@DeclareParents用于定义引介通知，相当于IntroductionInterceptor。

2）切面类：

import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.After;
import org.aspectj.lang.annotation.AfterReturning;
import org.aspectj.lang.annotation.AfterThrowing;
import org.aspectj.lang.annotation.Around;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Before;
import org.aspectj.lang.annotation.Pointcut;
import org.springframework.stereotype.Component;
/**
 * 切面类，在此类中编写通知
 */
@Aspect
@Component
public class MyAspect {
	// 定义切入点表达式
	@Pointcut("execution(* com.lydms.jdk.*.*(..))")
	// 使用一个返回值为void、方法体为空的方法来命名切入点
	private void myPointCut(){}
	// 前置通知
	@Before("myPointCut()")
	public void myBefore(JoinPoint joinPoint) {
		System.out.print("前置通知 ：模拟执行权限检查...,");
		System.out.print("目标类是："+joinPoint.getTarget() );
		System.out.println(",被织入增强处理的目标方法为："
		               +joinPoint.getSignature().getName());
	}
	// 后置通知
	@AfterReturning(value="myPointCut()")
	public void myAfterReturning(JoinPoint joinPoint) {
		System.out.print("后置通知：模拟记录日志...," );
		System.out.println("被织入增强处理的目标方法为："
		              + joinPoint.getSignature().getName());
	}
	// 环绕通知	
	@Around("myPointCut()")
	public Object myAround(ProceedingJoinPoint proceedingJoinPoint) 
            throws Throwable {
		// 开始
		System.out.println("环绕开始：执行目标方法之前，模拟开启事务...");
		// 执行当前目标方法
		Object obj = proceedingJoinPoint.proceed();
		// 结束
		System.out.println("环绕结束：执行目标方法之后，模拟关闭事务...");
		return obj;
	}
	// 异常通知
	@AfterThrowing(value="myPointCut()",throwing="e")
	public void myAfterThrowing(JoinPoint joinPoint, Throwable e) {
		System.out.println("异常通知：" + "出错了" + e.getMessage());
	}
	// 最终通知
	@After("myPointCut()")
	public void myAfter() {
		System.out.println("最终通知：模拟方法结束后的释放资源...");
	}
}

3）注解配置要扫描的包：

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
  xmlns:aop="http://www.springframework.org/schema/aop"
  http://www.springframework.org/schema/context/spring-context-4.3.xsd">
      <!-- 指定需要扫描的包，使注解生效 -->
      <context:component-scan base-package="com.lydms" />
      <!-- 启动基于注解的声明式AspectJ支持 -->
      <aop:aspectj-autoproxy />
</beans>

4）测试类：

import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
import com.lydms.jdk.UserDao;
// 测试类
public class TestAnnotationAspectj {
	public static void main(String args[]) {
		String xmlPath = 
                  "com/lydms/aspectj/annotation/applicationContext.xml";
		ApplicationContext applicationContext = 
                 new ClassPathXmlApplicationContext(xmlPath);
		// 1 从spring容器获得内容
		UserDao userDao = (UserDao) applicationContext.getBean("userDao");
		// 2 执行方法
		userDao.addUser();
	}
}

五、Spring boot集成AspectJ开发

1、Pom.xml

<!--不指定版本的原因,如不指定版本,会默认下载springboot对应版本的jar -->
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-aop</artifactId>
</dependency>

2、Controller.java

import com.lydms.common.Result;
import com.lydms.pojo.English;
import com.lydms.service.WordAddService;
import org.apache.commons.lang.StringUtils;
import org.apache.logging.log4j.LogManager;
import org.apache.logging.log4j.Logger;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;
import org.springframework.web.multipart.MultipartFile;

import java.io.IOException;

@RestController
@RequestMapping("/add")
public class WordAddController {
    private static final Logger logger = LogManager.getLogger(WordAddController.class);

    @Autowired
    private WordAddService wordAddService;

    /**
     * 添加英语
     * @throws Exception
     */
    @RequestMapping(value = "/english", method = {RequestMethod.POST})
    public ApiResult addEnglish(@RequestBody English en) {

//        1、将单词存入数据库
        English result = wordAddService.addEnglish(en);
        return ApiResult.succ(result);
    }
}

3、切面类(Aspect.java)

import com.fasterxml.jackson.databind.ObjectMapper;
import org.apache.logging.log4j.LogManager;
import org.apache.logging.log4j.Logger;
import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.annotation.AfterReturning;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Before;
import org.aspectj.lang.annotation.Pointcut;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.core.annotation.Order;
import org.springframework.stereotype.Component;
import org.springframework.web.context.request.RequestContextHolder;
import org.springframework.web.context.request.ServletRequestAttributes;

import javax.servlet.http.HttpServletRequest;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Enumeration;

@Aspect
@Order(5)
@Component
public class ControllerAspect {

    private static final Logger logger = LogManager.getLogger(ControllerAspect.class);

    private ThreadLocal<Long> startTime = new ThreadLocal<Long>();

    @Autowired
    private ObjectMapper mapper;
    
    public ControllerAspect() {
    }

    @Pointcut("execution(public * com.ldyms.controller.*.*(..))")
    public void webLog() {
    }

    @Before("webLog()")
    public void doBefore(JoinPoint joinPoint) throws Throwable {
        startTime.set(System.currentTimeMillis());
        ServletRequestAttributes attributes = (ServletRequestAttributes) RequestContextHolder.getRequestAttributes();
        HttpServletRequest request = attributes.getRequest();

        Enumeration<String> enums = request.getParameterNames();
        ArrayList params = new ArrayList();

        while (enums.hasMoreElements()) {
            String paraName = enums.nextElement();
            String param = paraName + ":" + request.getParameter(paraName);
            params.add(param);
        }

        logger.info("request Url:{},Params:{}",(request.getRequestURL().toString()),params);
        logger.info("request Methods:{}", Arrays.toString(joinPoint.getArgs()));
    }

    @AfterReturning(returning = "ret", pointcut = "webLog()")
    public void doAfterReturning(Object ret) throws Throwable {
        logger.info("RESPONSE: {} ", this.mapper.writeValueAsString(ret));
        logger.info("SPEND TIME: {} ms", System.currentTimeMillis() - startTime.get());
    }
}
ha_lydms
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 6
    评论
专栏目录
Spring AOP
RuanLiyufei的博客
05-19 262
3.1 Spring AOP简介 3.1.1 什么是AOP 3.1.2 AOP术语 3.2 动态代理 3.3 基于代理类的AOP实现 3.4 AspectJ开发
Spring的基本应用——基于注解的声明式AspectJ(idea版)
鹿谷門実的博客
09-13 360
与基于代理类的AOP实现相比,基于XML的声明式AspectJ要便捷多,但是它也存在着一些缺点,那就是要在Spring文件中配置大量的代码信息。为了解决这个问题，AspectJ框架为AOP的实现提供了一套注解，用以取代Spring配置文件中为实现AOP功能所配置的臃肿代码。 @Aspect 定义类为切入类 @Pointcut 声明一个切入策略供 @Before 被切入方法执...
Spring AOP面向切面编程AspectJ详解
hjw0505521的博客
03-18 334
AspectJ是基于Java语言的AOP框架。 <aop:aspect>>：子元素 <aop:pointcut>：配置全局切入点 <aop:before>:配置前置通知 <aop:after-retruning>:配置后置通知 <aop:around>:配置环绕通知 <aop:after-throwing>:配置异常通知...
Spring框架学习3——AOP的使用
wsdchong的博客
05-09 252
前言：这个文章的定位不是实现的步骤，而是实现过程中遇到的问题。并且我写的步骤是别人的步骤的记录，算不了什么，后面对使用过程中遇到的问题以及解决的方法才是自己写的，有价值的地方。 写这篇文章的出发点一个是为了保障自己学以致用，一个是查漏补缺。 而且很多教程虽然说按照那个步骤可以成功，但也可能不成功，要么是自己操作有误，要么是版本变了，还有可能自己基础没学好，前置知识不够。我最开始写Java的时候连创建父类和接口类都不会，直接创建一个类，然后复制粘贴，最后报错。僵硬~ 写这类博客，即写步骤，又写操作过程中
AspectJ开发
梦友
11-16 497
1.基于XML的声明式AspectJ 2.基于注解的声明式AspectJ
03. Spring AOP
陈政材CarisCzc的博客
02-16 273
Spring AOP1 基本概念1.1 AOP相关术语2 动态代理2.1 JDK动态代理2.2 CGLIB代理 1 基本概念 AOP的全称是Aspect-Oriented Programming，即面向切面编程（也称面向方面编程）。它是面向对象编程（OOP）的一种补充，目前已成为一种比较成熟的编程方式 在传统的业务处理代码中，通常都会进行事务处理、日志记录等操作。虽然使用OOP可以通过组合或者...
面向切面编程SpringAOP（什么是AOP,AOP相关术语，JDK动态代理，CGLIB 代理，基于XML的声明式 AspectJ，基于注解的声明式 AspectJ）
qq_46656580的博客
03-17 635
1. 什么是AOP AOP，即面向切面编程，它是面向对象编程(OOP)的一种补充。 在想重用一段代码的时候，传统的 OOP 思想是父子关系继承来达到纵向的代码重用，但是对于两个没有关系的对象重用一段代码，用 OOP 就难以实现了，AOP 也是为解决这种问题而应运而生，采取横向抽取机制，将分散在各个方法中的重复代码提取出来，然后在程序编译或运行时，再将这些提取出来的代码应用到需要执行的地方。 2. AOP相关术语 Aspect(切面)：封装的用于横向插入系统功能的类，例如事务、日志等要插入系统功能，而封
【Spring】AspectJ：基于注解的声明式AspectJ
wlc19981111的博客
05-15 182
package com.itheima.jdk; public interface UserDao { public void addUser(); public void deleteUser(); } package com.itheima.jdk; import org.springframework.stereotype.Repository; @Repository("userDao") public class UserDaoImpl implements UserDao {// 目标类
SpringAOP(四)
ah_hzy的博客
06-23 277
1.专业术语 Aspect(切面):指封装的用于横向插入系统功能(如事务、日志等的类)，该类要被spring容器识别为切面，需要在配置文件中通过<bean>元素指定 Joinpoint(连接点):指对象的一个操作,例如方法的调用或者异常的抛出,在SpringAOP中,连接点就是指方法的调用. Poincut(切入点):指的是类或方法名,如某个通知要应用到所有以add开头的方法中,...
AOP进阶练习
RuanLiyufei的博客
06-15 256
文章目录添加依赖：配置spring-service.xml基于注解的声明式AspectJ 添加依赖： <!-- https://mvnrepository.com/artifact/org.springframework/spring-aspects --> <dependency> <groupId>org.springframework</groupId> <artifactId>spring-aspects</artif
Spring Aop使用实例
03-23
Spring Aop的使用实例
JavaEE Spring AOP使用
04-16
压缩包中函数Spring AOP开发时使用注解和xml文件配置demo
SpringAOP使用介绍，从前世到今生
02-24
SpringAOP发展到现在出现的全部3种配置方式。由于Spring强大的向后兼容性，实际代码中往往会出现很多配置混杂的情况，而且居然还能工作，本文希望帮助大家理清楚这些知识。我们先来把它们的概念和关系说说清楚。AOP...
spring aop使用教程
03-12
spring aop使用教程
IDEA 自定义注解(类注释、方法注释)
热门推荐
lydms的博客
12-07 2万+
文章目录一、生成类注释1、打开设置位置2、将自定义的类注解规则，复制到Class中。3、使用：新建类的时候会自动加上注解二、自定义方法注解1、打开设置2、添加自定义注解模板组3、添加自定义注解模板4、设置模板的作用范围5、自定义㢟规则6、使用自定义注解三、注意事项1、在类上注解，没有显示入参和返回值2、自定义注解参数及使用方式 一、生成类注释 1、打开设置位置 打开File —> Settings —> Editor —> File and Code Templates —> Fi
java获取当前日期和时间（各种方法对比）
lydms的博客
01-11 9235
一、简介 使用到的时间类有： System.currentTimeMillis()： System.currentTimeMillis()产生一个当前的毫秒，这个毫秒其实就是自1970年1月1日0时起的毫秒数，类型为long； Date： 类 Date 表示特定的瞬间，精确到毫秒。 从 JDK 1.1 开始，应该使用 Calendar 类实现日期和时间字段之间转换，使用 DateFormat 类来...
Float.compare()和Double.compare()的使用
lydms的博客
01-19 9204
文章目录1、简介2、案例 1、简介 public static int compare(float f1, float f2) ; 底层的源码为： public static int compare(float f1, float f2) { if (f1 < f2) return -1; if (f1 > f2) return 1; ...
Java发送Http请求（HttpClient）
lydms的博客
01-18 8940
文章目录一、简介1、HttpClient2、HTTP协议的特点如下3、使用HttpClient发送请求、接收响应很简单，一般需要如下几步即可二、spring boot集成HttpClient1、pom.xml添加httpclient的jar包依赖2、测试类3、工具类 一、简介 1、HttpClient HttpClient 是Apache HttpComponents 下的子项目，用来提供高效的、...
阿里云基础测试题（Java基础知识—2019-7-10）
lydms的博客
07-10 7366
public class Demo { public static void main(String args[]) { int num = 2147483647 ; long temp = num + 2L ; System.out.println(num) ; } } 最终的执行结果是什么？ A .-...
spring aop 使用
最新发布
09-23
Spring AOP 是一个用于实现面向切面编程的框架。...在使用 Spring AOP 时，需要引入 Spring AOP 和 Spring Context 相关的包，并在配置文件中进行相应的配置。可以通过 Maven 或其他构建工具来引入相关依赖。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 6
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

ha_lydms

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值