hutool学习第一天-aop

已于 2024-07-29 09:55:33 修改
阅读量436 收藏 5
点赞数 9
文章标签： java spring boot
于 2024-07-29 09:51:50 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/u010913170/article/details/140718424
版权

hutool源码学习第一天-aop

普通实现方式

1. JDK 动态代理

JDK 动态代理是基于 Java 反射机制的一种代理方式，它允许在运行时动态创建实现了某些接口的代理对象。它的主要特点是：

  • 要求：被代理的类必须实现一个或多个接口。
  • 代理类：由 java.lang.reflect.Proxy 类动态生成。
  • 核心接口：InvocationHandler。
详细实现步骤：

  1. 定义接口：创建一个接口，规定要代理的方法。

    public interface HelloService {
    void sayHello();
}

  2. 实现接口：创建一个实现接口的具体类。

    public class HelloServiceImpl implements HelloService {
    @Override
    public void sayHello() {
        System.out.println("Hello, world!");
    }
}

  3. 创建 InvocationHandler：实现 InvocationHandler 接口，以便在方法调用时插入自定义逻辑。

    import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;

public class MyInvocationHandler implements InvocationHandler {
    private Object target;

    public MyInvocationHandler(Object target) {
        this.target = target;
    }

    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        System.out.println("Before method: " + method.getName());
        Object result = method.invoke(target, args);
        System.out.println("After method: " + method.getName());
        return result;
    }
}

  4. 生成代理对象：使用 Proxy.newProxyInstance 创建代理对象。

    import java.lang.reflect.Proxy;

public class JDKProxyDemo {
    public static void main(String[] args) {
        HelloService target = new HelloServiceImpl();
        HelloService proxy = (HelloService) Proxy.newProxyInstance(
            target.getClass().getClassLoader(),
            target.getClass().getInterfaces(),
            new MyInvocationHandler(target)
        );
        proxy.sayHello();
    }
}

2. Cglib 动态代理

Cglib 代理通过继承被代理的类来创建代理对象，因此不需要被代理的类实现接口。Cglib 主要用于类级别的代理。

详细实现步骤：

  1. 添加 Cglib 依赖：首先，需要在项目中引入 Cglib 依赖（如果使用 Maven）。

    <dependency>
    <groupId>cglib</groupId>
    <artifactId>cglib</artifactId>
    <version>3.3.0</version>
</dependency>

  2. 定义普通类：创建一个需要被代理的普通类。

    public class HelloService {
    public void sayHello() {
        System.out.println("Hello, world!");
    }
}

  3. 实现 MethodInterceptor：实现 MethodInterceptor 接口以定义拦截逻辑。

    import net.sf.cglib.proxy.MethodInterceptor;
import net.sf.cglib.proxy.MethodProxy;

public class MyMethodInterceptor implements MethodInterceptor {
    private Object target;

    public MyMethodInterceptor(Object target) {
        this.target = target;
    }

    @Override
    public Object intercept(Object obj, java.lang.reflect.Method method, Object[] args, MethodProxy proxy) throws Throwable {
        System.out.println("Before method: " + method.getName());
        Object result = proxy.invoke(target, args);
        System.out.println("After method: " + method.getName());
        return result;
    }
}

  4. 创建代理对象：使用 Enhancer 来创建代理对象。

    import net.sf.cglib.proxy.Enhancer;

public class CglibProxyDemo {
    public static void main(String[] args) {
        HelloService target = new HelloService();
        Enhancer enhancer = new Enhancer();
        enhancer.setSuperclass(target.getClass());
        enhancer.setCallback(new MyMethodInterceptor(target));
        HelloService proxy = (HelloService) enhancer.create();
        proxy.sayHello();
    }
}

3. Spring AOP 的 Cglib 代理

Spring AOP 可以通过 Cglib 代理来实现对类的增强。Spring AOP 在底层使用了 Cglib 来生成代理类，尤其在被代理的类没有实现接口时。

详细实现步骤：

  1. 添加 Spring AOP 依赖：在项目中引入 Spring AOP 相关的依赖（如果使用 Maven）。

    <dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-aop</artifactId>
    <version>5.3.24</version>
</dependency>
<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-context</artifactId>
    <version>5.3.24</version>
</dependency>

  2. 定义服务类：创建一个使用 Spring 注解的服务类。

    import org.springframework.stereotype.Service;

@Service
public class HelloService {
    public void sayHello() {
        System.out.println("Hello, world!");
    }
}

  3. 创建切面类：使用 @Aspect 注解定义切面，并实现切面逻辑。

    import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.Around;
import org.aspectj.lang.annotation.Aspect;
import org.springframework.stereotype.Component;

@Aspect
@Component
public class LoggingAspect {
    @Around("execution(* HelloService.sayHello(..))")
    public Object logAround(ProceedingJoinPoint joinPoint) throws Throwable {
        System.out.println("Before method: " + joinPoint.getSignature().getName());
        Object result = joinPoint.proceed();
        System.out.println("After method: " + joinPoint.getSignature().getName());
        return result;
    }
}

  4. 配置 Spring AOP：配置 Spring 来启用 AOP 功能。

    import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.EnableAspectJAutoProxy;

@Configuration
@EnableAspectJAutoProxy
@ComponentScan(basePackages = "your.package")
public class AppConfig {
}

  5. 主程序：使用 Spring 上下文来获取服务类的代理对象。

    import org.springframework.context.ApplicationContext;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;

public class SpringAopDemo {
    public static void main(String[] args) {
        ApplicationContext context = new AnnotationConfigApplicationContext(AppConfig.class);
        HelloService helloService = context.getBean(HelloService.class);
        helloService.sayHello();
    }
}

总结

  • JDK 动态代理：适用于代理实现了接口的类，使用 java.lang.reflect.Proxy 生成。
  • Cglib 代理：适用于代理没有实现接口的类，通过继承生成代理类。
  • Spring AOP Cglib 代理：Spring 使用 Cglib 实现对类的增强，支持注解方式的切面编程。

hutool工具包实现方式

引入hutool工具包

	<dependency>
	       <groupId>cn.hutool</groupId>
	       <artifactId>hutool-all</artifactId>
	       <version>5.3.6</version>
	</dependency>

ProxyFactory生成代理对象

  • CglibProxyFactory 基于Cglib的切面代理工厂
  • JdkProxyFactory JDK实现的切面代理
  • SpringCglibProxyFactory 基于Spring-cglib的切面代理工厂
  1. createProxy

createProxy默认使用Cglib 动态代理

在这里插入图片描述

  • 如何使用
public void test(){
        Cat proxy = ProxyFactory.createProxy(new Cat(), SimpleAspect.class);
        proxy.eat();
    }

new Cat()为目标对象，SimpleAspect.class为切面对象，hutool提供了两个切面对象类

  • SimpleAspect类，是基本类，所有自定义开发的切面对象都需要集成该类
  • TimeIntervalAspect类，为通过日志打印方法的执行时间的切面
public void TimeIntervalAspectTest(){
        Cat proxy = ProxyFactory.createProxy(new Cat(), TimeIntervalAspect.class);
        proxy.eat();
    }

在这里插入图片描述
2. proxy

如果不想使用默认的的Cglib 动态代理，可以使用该方法自定义创建

	 @Test
    public void ProxyTest(){
        ProxyFactory proxyFactory = new ProxyFactory() {
            @Override
            public <T> T proxy(T target, Aspect aspect) {
                /**
                 * 1、CglibProxyFactory 基于Cglib的切面代理工厂
                 * 2、JdkProxyFactory JDK实现的切面代理
                 * 3、SpringCglibProxyFactory 基于Spring-cglib的切面代理工厂
                 */
                return JdkProxyFactory.createProxy(target, aspect);
            }
        };
        Cat proxy = ProxyFactory.createProxy(new Cat(), TimeIntervalAspect.class);
        proxy.eat();
    }

如何创建自己的切面对象类

  1. 继承SimpleAspect简单切面类

简单切面类，不做任何操作 可以继承此类实现自己需要的方法即可

	public class MyAopAspect extends SimpleAspect {
    @Override
    public boolean before(Object target, Method method, Object[] args) {
        System.out.println("before");
        return true;
    }

    @Override
    public boolean after(Object target, Method method, Object[] args, Object returnVal) {
        System.out.println("after");
        return true;
    }

    @Override
    public boolean afterException(Object target, Method method, Object[] args, Throwable e) {
        System.out.println("afterException");
        return true;
    }
}

	@Test
    public void testMyAopAspect(){
        Cat proxy = ProxyFactory.createProxy(new Cat(), MyAopAspect.class);
        proxy.eat();
    }
孑疋
关注
  • 9
    点赞
  • 踩
  • 5
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
hutool 获取某月最后一天_Hutool使用指南
weixin_39600319的博客
12-20 4778
Hutool是一个Java工具包，它帮助我们简化每一行代码，避免重复造轮子。如果你有需要用到某些工具方法的时候，不妨在Hutool里面找找，可能就有。本文将对Hutool中的常用工具类和方法进行介绍。##一、简介一个Java基础工具类，对文件、流、加密解密、转码、正则、线程、XML等JDK方法进行封装，组成各种Util工具类，同时提供以下组件：hutool-core 核心，包括Bean操作、日期、...
hutool中的threadutil_Hutool - 好用的Java工具类库
weixin_39588419的博客
12-18 1525
Hutool是一个Java工具包，它帮助我们简化每一行代码，避免重复造轮子。如果你有需要用到某些工具方法的时候，不妨在Hutool里面找找，可能就有。本文将对Hutool中的常用工具类和方法进行介绍。9 n, v+ c0 |" i$ l一、简介. c; v) d: q8 C" {0 j2 p" f, }, [9 Y3 F% S5 j一个Java基础工具类，对文件、流、加密解密、转码、正则、线程、X...
Hutool使用总结（VIP典藏版）
2401_84557821的博客
05-23 662
一次偶然，从朋友那里得到一份“java高分面试指南”，里面涵盖了25个分类的面试题以及详细的解析：JavaOOP、Java集合/泛型、Java中的IO与NIO、Java反射、Java序列化、Java注解、多线程&并发、JVM、Mysql、Redis、Memcached、MongoDB、Spring、Spring Boot、Spring Cloud、RabbitMQ、Dubbo 、MyBatis 、ZooKeeper 、数据结构、算法、Elasticsearch 、Kafka 、微服务、Linux。
关于Hutool的模块使用说明方法
weimeilayer的博客
06-18 481
【代码】关于Hutool的模块使用说明方法。
Hutool使用总结（VIP典藏版）(1)
2401_83064295的博客
05-23 1074
切莫死记硬背，小心面试官直接让你出门右拐1000道互联网Java面试题：Java高级架构面试知识整理：;
Hutool，一个贼好用的 Java 工具类库，Java开发必备利器
Thinkingcao的专栏
11-24 3070
工欲善其事必先利其器！ 今天给大家介绍一款超级强力的Java工具类库Hutool 。 一、简介 Hutool是一个小而全的Java工具类库，通过静态方法封装，降低相关API的学习成本，提高工作效率，使Java拥有函数式语言般的优雅，让Java语言也可以“甜甜的”。 Hutool中的工具方法来自于每个用户的精雕细琢，它涵盖了Java开发底层代码中的方方面面，它既是大型项目开发中解决小问题的利器，也是小型项目中的效率担当； Hutool是项目中“util”包友好的替代，它节省了开发人员对项目中公用类和公用工具方
hutool工具
usa_washington的博客
08-30 1873
参考：https://www.hutool.cn/
推荐一款优秀的国内开源工具类库Hutool，让你的代码量减少90%
程序员云帆哥的博客
06-22 5420
Hutool是一个小而全的Java工具类库，通过静态方法封装，降低相关API的学习成本，提高工作效率，使Java拥有函数式语言般的优雅，让Java语言也可以“甜甜的”。
系统接口日志记录-AOP
bin929的博客
11-18 4678
在进行系统开发的时候，系统提供给前端或者第三方使用的接口，要对接口的调用情况（接口的接收的参数、返回的结果、调用者、调用接口的ip等）进行记录。通过Spring AOP的***环绕通知***可以很容易实现该功能。实现该功能对调用接口数据的记录也便于后续项目出现问题的时候能够溯源 以下列出在项目中的实际用例。 项目中的架构如图： SysInterfaceLogAspect ： package com.taoan.admin.common.aspect; import cn.hutool.core.util
开发工具 spring-aop-4.3.6.RELEASE
05-31
开发工具 spring-aop-4.3.6.RELEASE开发工具 spring-aop-4.3.6.RELEASE开发工具 spring-aop-4.3.6.RELEASE开发工具 spring-aop-4.3.6.RELEASE开发工具 spring-aop-4.3.6.RELEASE开发工具 spring-aop-4.3.6.RELEASE...
2024-spring-aop学习项目
01-26
《深入理解Spring AOP：2024春季学习项目指南》 ...通过这个2024春季AOP学习项目，开发者将有机会亲手实践上述概念，深入理解Spring AOP的精髓，从而在实际项目中更好地运用这一强大的工具，提升代码质量与工程效率。
spring-aop-5.2.0.RELEASE-API文档-中文版.zip
07-13
赠送jar包：spring-aop-5.2.0.RELEASE.jar； 赠送原API文档：spring-aop-5.2.0.RELEASE-javadoc.jar； 赠送源代码：spring-aop-5.2.0.RELEASE-sources.jar； 赠送Maven依赖信息文件：spring-aop-5.2.0.RELEASE.pom；...
spring-aop.jar各个版本
07-12
spring-aop-1.1.1.jar spring-aop-1.2.6.jar spring-aop-1.2.9.jar spring-aop-2.0.2.jar spring-aop-2.0.6.jar spring-aop-2.0.7.jar spring-aop-2.0.8.jar spring-aop-2.0.jar spring-aop-2.5.1.jar spring-aop-...
spring-aop-6.0.2.jar
10-25
spring-aop-6.0.2.jar
golang 接口
m0_70982551的博客
07-24 918
接口定义了一组方法，这些方法没有具体的实现。接口类型的变量可以存储任何实现了这些方法的类型的值。// 更多方法...在Go语言中，接口值是指存储了实现某个接口的具体类型值的变量。接口值由两部分组成：1.动态类型：这是接口值当前存储的实际类型。2.动态值：这是实际存储的值，该值必须实现了接口中定义的所有方法。
Swagger使用Map接受参数时，页面如何显示具体参数及说
a1058926697的博客
07-26 496
后端使用Map接受参数，要求在swagger页面上显示具体的参数名称、类型及说明。当Map接受参数数量少时，可以使用Swagger自带的注解。自定义注解 @ApiGlobalModel。编写处理注解对应的插件。
springboot之自动装配
weixin_50153914的博客
07-23 608
Spring Boot 通过一系列注解和条件配置实现了自动装配机制，使得开发者无需手动配置大量的 XML 文件或 Java 配置类。自动配置机制利用文件中的自动配置类，并结合条件注解和组件扫描，实现了灵活且强大的自动装配功能。这样，开发者可以专注于业务逻辑的实现，而无需处理繁琐的配置细节。
Java的@DateTimeFormat注解与@JsonFormat注解的使用对比
最新发布
訾博（ZiBo）的博客
07-27 577
在Spring和Jackson框架中，日期和时间格式化是一个常见需求。注解主要用于Spring的表单绑定，而注解则用于Jackson的JSON序列化和反序列化。了解这两个注解的使用场景和方法，可以帮助开发者更高效地处理日期和时间。和是处理日期和时间格式化的两个重要注解。主要用于Spring MVC的请求参数绑定，而主要用于Jackson的JSON序列化和反序列化。了解它们的使用场景和功能，可以帮助开发者更高效地处理日期和时间格式化需求。通过本文的介绍，希望读者能够更清晰地理解和。
spring-aop与spring-boot-starter-aop的区别
09-22
spring-aop与spring-boot-starter-aop的区别在于配置的简化程度和依赖的引入方式。spring-aop是基于Spring框架的AOP实现方式，需要通过XML配置文件来定义切面和通知。而spring-boot-starter-aop是针对Spring Boot应用程序提供的一种简化配置和使用的方式，可以通过注解和Java配置来定义切面和通知。使用spring-boot-starter-aop可以更方便地进行AOP操作，并且不需要额外引入独立的AOP依赖。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

孑疋

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

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

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

打赏作者

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

抵扣说明：

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

余额充值