Spring框架 —— AOP面向切面编程

最新推荐文章于 2024-09-27 00:45:01 发布
最新推荐文章于 2024-09-27 00:45:01 发布
阅读量381 收藏
点赞数
分类专栏： Java开发 文章标签： java spring AOP
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_62706049/article/details/132022345
版权

前言

        前面荔枝已经梳理了Spring框架中的IOC部分的知识，接下来荔枝继续梳理Spring框架的另一大重点：AOP面向切面编程。在这篇文章中，荔枝会着重弄清楚AOP的概念并对实现AOP的两种方式进行梳理，同时荔枝也会相应给出代码样例。毕竟荔枝始终觉得只有文字的描述是苍白无力的，有代码其实理解起来会更快哈哈哈。

文章目录

前言

一、代理模式和AOP概念

1.1 代理模式

1.2 AOP概念

二、基于注解方式实现AOP

2.1 动态代理分类和依赖引入

2.2 切入点表达式以及五种通知类型 

2.3 重用切入点表达式

2.4 切面的优先级 

三、基于XML方式实现AOP

总结

一、代理模式和AOP概念

在开发中我们常常考虑将不同功能的程序分离出来降低系统的耦合度，也就是解耦操作。也就是说，通常在针对一些附加功能的时候我们需要一种方法把子类中重复的代码注入到父类中。

1.1 代理模式

        代理模式是设计模式中的一种，属于结构型模式。它的作用就是通过提供一个代理类，让我们在调用目标方法的时候，不再是直接对目标方法进行调用，而是通过代理类间接调用。让不属于目标方法核心逻辑的代码从目标方法中剥离出来一一解耦。调用目标方法时先调用代理对象的方法，减少对目标方法的调用，同时让附加功能能够集中在一起也有利于统一维护。代理主要分为两种：静态代理和动态代理。

静态代理

静态代理解决了高耦合的问题，通过一个代理类构造方法获取执行类的对象并调用其add方法实现接口功能，并在前后加上附加功能比如日志文件。

package com.crj.aop;

public class CalculatorStaticProxy implements Calaulator{
    //将代理目标对象传递进来
    private Calaulator calaulator;
    public CalculatorStaticProxy(Calaulator calaulator) {
        this.calaulator = calaulator;
    }
    @Override
    public int add(int i, int j) {
        //输出日志
        System.out.println("[日志]add方法开始，参数是：i="+i+"、j="+j);
        calaulator.add(i,j);
        //输出日志
        System.out.println("[日志]add方法结束");
        return 0;
    }
}

静态代理确实实现了解耦，但是由于代码都写死了，完全不具备任何的灵活性。就拿日志功能来说，将来其他地方也需要附加日志，那还得声明多个静态代理类，那就产生了大量重复的代码，日志功能还是分散的，没有统一管理。

进一步的需求：将日志功能集中到一个代理类中，将来有任何日志需求，都通过这一个代理类来实现，这就需要使用动态代理技术了。

动态代理

Java种支持使用Proxy.newProxyInstance(classLoader,interfaces,invocationHandler)来实现接口的动态代理，需要三个参数：需代理类的类加载器、需代理类的实现接口数组和重写的代理方法。其中第三个参数实现目标的代理方法借助InvocationHandler类种的invoke方法来实现。

动态代理类

package com.crj.spring6.aop;

import java.lang.reflect.Array;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
import java.util.Arrays;

//实现动态代理
public class ProxyFactory {
    //目标对象
    private Object target;
    public ProxyFactory(Object target) {
        this.target = target;
    }

    //返回代理对象
    public Object getProxy(){
        /**
         * 参数说明
         * Proxy.newProxyInstance()方法
         * 1.类加载器ClassLoader loader 加载动态生成代理类的类加载器
         * 2.Class[] interfaces 目标对象实现的所有接口的class类型数组
         * 3.IncocationHandler 设置代理对象实现目标对象方法的过程
         */
        //类加载器
        ClassLoader classLoader = target.getClass().getClassLoader();
        //目标对象实现的所有接口的class类型数组
        Class<?>[] interfaces = target.getClass().getInterfaces();
        //使用匿名内部类来实现接口
        InvocationHandler invocationHandler = new InvocationHandler(){
            @Override
            public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
                /**
                 * 参数
                 * 第一个参数：代理对象
                 * 第二个参数：需要重写的目标对象的方法
                 * 第三个参数：method方法里面的参数
                 */
                //方法调用之前输出日志
                System.out.println("[动态代理日志]"+method.getName()+"参数："+ Arrays.toString(args));
                //调用目标方法
                Object result = method.invoke(target, args);
                //方法调用之后输出日志
                System.out.println("[动态代理日志]"+method.getName()+"结果："+ result);

                return result;
            }
        };
        return Proxy.newProxyInstance(classLoader,interfaces,invocationHandler);
    }

}

测试类

package com.crj.spring6.aop;

public class TestCal {
    public static void main(String[] args) {
        //创建代理对象
        ProxyFactory proxyFactory = new ProxyFactory(new CalculatorImpl());
        //获取代理对象
        Calaulator proxy = (Calaulator)proxyFactory.getProxy();
        proxy.add(1,2);
    }
}

1.2 AOP概念

        AOP(Aspect Oriented Programming)是一种设计思想，是软件设计领域中的面向切面编程，它是面向对象编程的一种补充和完善，它以预编译方式和运行期动态代理方式实现，在不修改源代码的情况下，给程序动态统一添加额外功能。利用AOP可以对业务逻辑的各个部分进行隔离，从而使得业务逻辑各部分之间的耦合度降低，提高程序的可重用性，同时提高了开发的效率，使程序是松耦合的。

相关术语

横切关注点

分散在各个模块中解决同一类问题的，或者说是从每个方法种抽取出来的同类非核心也无就乘坐横切关注点，比如：日志管理、用户验证等。换句话说，有几个附加功能就有几个横切关注点。

通知（增强）

每一个横切关注点上要做的事情都需要写一个方法来实现，这样的方法就叫通知方法，有五种通知类型：

  • 前置通知：在被代理的目标方法前执行
  • 返回通知：在被代理的目标方法成功结束后执行
  • 异常通知：在被代理的目标方法异常结束后执行
  • 后置通知：在被代理的目标方法最终结束后执行
  • 环绕通知：使用try..catch.finally结构围绕整个被代理的目标方法，包括上面四种通知对应的所有位置

切面

封装通知方法的类

目标

被代理的目标对象

代理

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

连接点

允许使用通知的地方

切入点 

        定位连接点的方式。每个类的方法中都包含多个连接点，所以连接点是类中客观存在的事物（从逻辑上来说）。如果把连接点看作数据库中的记录，那么切入点就是查询记录的SQL语句。Spring的AOP技术可以通过切入点定位到特定的连接点。通俗说，要实际去增强的方法切点通过org.springframework.aop.Pointcut接口进行描述，它使用类和方法作为连接点的查询条件。

二、基于注解方式实现AOP

我们知晓，AOP面向切面编程的底层也是通过动态代理来实现的，所以对于动态代理我们除了了解基本的代理分类之外还需要明确AOP种如何使用动态代理的方式来实现AOP。

2.1 动态代理分类和依赖引入

        AOP动态代理有两种：JDK动态代理和CGlib动态代理，分别对应有接口和无接口的动态代理。JDK动态代理会生成接口实现类的代理对象，而CGlib动态代理是通过继承被代理对象并重写的方式实现的。 

pom.xml文件

项目的环境中即pom.xml文件中需要引入aop和aspects依赖。

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>

    <groupId>com.crj</groupId>
    <artifactId>spring6</artifactId>
    <version>1.0-SNAPSHOT</version>
    <packaging>pom</packaging>
    <modules>
        <module>spring-first</module>
        <module>spring6-ioc-xml</module>
        <module>spring6-ioc-annotation</module>
        <module>spring6-aop</module>
    </modules>

    <properties>
        <maven.compiler.source>17</maven.compiler.source>
        <maven.compiler.target>17</maven.compiler.target>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
    </properties>

    <!--    此处引入spring依赖-->
    <dependencies>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context</artifactId>
            <version>6.0.2</version>
        </dependency>
        <!--  引入junit依赖-->
        <dependency>
            <groupId>org.junit.jupiter</groupId>
            <artifactId>junit-jupiter-api</artifactId>
            <version>5.6.3</version>
        </dependency>
        <!--    引入log4j2的依赖-->
        <dependency>
            <groupId>org.apache.logging.log4j</groupId>
            <artifactId>log4j-core</artifactId>
            <version>2.19.0</version>
        </dependency>
        <dependency>
            <groupId>org.apache.logging.log4j</groupId>
            <artifactId>log4j-slf4j2-impl</artifactId>
            <version>2.19.0</version>
        </dependency>
        <dependency>
            <groupId>jakarta.annotation</groupId>
            <artifactId>jakarta.annotation-api</artifactId>
            <version>2.1.1</version>
        </dependency>
        <!--spring aop依赖-->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-aop</artifactId>
            <version>6.0.2</version>
        </dependency>
        <!--spring aspects依赖-->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-aspects</artifactId>
            <version>6.0.2</version>
        </dependency>

    </dependencies>
</project>

除了环境总配置之外，还需要在项目中resources目录下的xml文件中配置开启组件扫描和aspectj自动代理。

<?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/aop http://www.springframework.org/schema/aop/spring-aop.xsd
       http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd
       http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">

    <!--开启组件扫描-->
    <context:component-scan base-package="com.crj.spring6.aop.annotationAop"></context:component-scan>
    <!--开启aspectj自动代理，为目标对象生成代理-->
    <aop:aspectj-autoproxy></aop:aspectj-autoproxy>
</beans>

2.2 切入点表达式以及五种通知类型 

在配置完环境依赖后，我们需要在切面类中定义通知的类型并设置切入点，Java中同个定义了几个注解来实现设置通知类型：

  • 前置通知 @Before(value = “切入点表达式”)
  • 返回通知 @AfterReturning
  • 异常通知 @AfterThrowing
  • 后置通知 @After()
  • 环绕通知 @Around()

需要注意切入点表达式的结构：execution(权限修饰符 方法返回值类型 切入点方法的全类名.方法名（方法参数列表)) 

前置通知 

package com.crj.spring6.aop.annotationAop;

import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.*;
import org.springframework.stereotype.Component;

import java.util.Arrays;

//切面类
@Aspect  //切面类
@Component  //IOC容器
public class LogAspect {

    //设置切入点和通知类型
    //通知类型：
    //    前置通知 @Before(value = “切入点表达式”)
    //    返回通知 @AfterReturning
    //    异常通知 @AfterThrowing
    //    后置通知 @After()
    //    环绕通知 @Around()

    //前置通知
    @Before(value = "execution(public int com.crj.spring6.aop.annotationAop.CalculatorImpl.add(..))")
    public void beforeMethod(JoinPoint joinPoint){
        String methodName = joinPoint.getSignature().getName();
        Object[] args = joinPoint.getArgs();
        System.out.println("Logger-.->前置通知，方法名："+methodName+",参数："+ Arrays.toString(args));
    }
}

返回通知

返回通知中我们在注解中可以通过returning属性获取执行目标增强方法后的返回值。

package com.crj.spring6.aop.annotationAop;

import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.*;
import org.springframework.stereotype.Component;

import java.util.Arrays;

//切面类
@Aspect  //切面类
@Component  //IOC容器
public class LogAspect {

    //返回通知
    @AfterReturning(value = "execution(* com.crj.spring6.aop.annotationAop.CalculatorImpl.*(..))",returning = "result")
    public void afterReturnMethods(JoinPoint joinPoint,Object result){
        //增强方法的名字
        String methodName = joinPoint.getSignature().getName();
        //增强方法的参数
        Object[] args = joinPoint.getArgs();
        //增强方法的返回值 result
        System.out.println("Logger-.->返回通知，方法名："+methodName+",参数："+ Arrays.toString(args)+"，目标方法的返回值："+result);
    }
    
}

异常通知

 在异常通知中可以通过throwing属性获得目标增强方法执行异常抛出的信息。

package com.crj.spring6.aop.annotationAop;

import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.*;
import org.springframework.stereotype.Component;

import java.util.Arrays;

//切面类
@Aspect  //切面类
@Component  //IOC容器
public class LogAspect {

    //异常通知
    @AfterThrowing(value = "execution(* com.crj.spring6.aop.annotationAop.CalculatorImpl.*(..))",throwing = "ex")
    public void afterThrowingMethod(JoinPoint joinPoint,Throwable ex){
        String methodName = joinPoint.getSignature().getName();
        Object[] args = joinPoint.getArgs();
        System.out.println("Logger-.->异常通知，方法名："+methodName+",参数："+ Arrays.toString(args)+"，异常方法的信息："+ex);
    }
}

环绕通知 

环绕通知需要注意的是@Around注解下的方法参数类型选择的是ProceedingJoinPoint，借助该类型对象的proceed的方法来调用目标函数。

package com.crj.spring6.aop.annotationAop;

import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.*;
import org.springframework.stereotype.Component;

import java.util.Arrays;

//切面类
@Aspect  //切面类
@Component  //IOC容器
public class LogAspect {

    //环绕通知
    @Around(value = "execution(* com.crj.spring6.aop.annotationAop.CalculatorImpl.*(..))")
    public Object aroundMethod(ProceedingJoinPoint joinPoint){
        String methodName = joinPoint.getSignature().getName();
        Object[] args = joinPoint.getArgs();
        String argString = Arrays.toString(args);
        Object result = null;
        try{
            System.out.println("环绕通知——>目标方法之前执行");
            //调用目标方法
            result = joinPoint.proceed();
            System.out.println("环绕通知——>目标方法返回值之后执行");

        }catch (Throwable throwable){
            System.out.println("环绕通知——>目标方法出现异常之后执行");

        }finally {
            System.out.println("环绕通知——>后置通知");
        }
        return result;
    }
}

2.3 重用切入点表达式

通过上述的四个通知例子我们发现，切入点表达式除了在一些特殊的场景需求下，其余的情况总是一样的，为了避免代码的冗余，我们可以通过重用切入点表达式来提高程序的可复用性。

//前置通知
@Before(value = "Pointcut()")
public void beforeMethod(JoinPoint joinPoint){
    String methodName = joinPoint.getSignature().getName();
    Object[] args = joinPoint.getArgs();
    System.out.println("Logger-.->前置通知，方法名："+methodName+",参数："+ Arrays.toString(args));
} 

@Pointcut(value = "execution(* com.crj.spring6.aop.annotationAop.CalculatorImpl.*(..))")
public void pointCut(){}

注意：上述是在同一个切面中的定义，在不同的切面中的话需要在通知的切入点表达式加上重用函数的全类名 

2.4 切面的优先级 

相同目标方法上同时存在多个切面时，可以通过切面的优先级控制切面的内外嵌套顺序：

  • 优先级高的切面：外面
  • 优先级低的切面：里面

主要是通过使用@Order注解来设定切面的优先级：

  • @Order(较小的数)：优先级高
  • @Order(较大的数)：优先级低 

三、基于XML方式实现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/aop http://www.springframework.org/schema/aop/spring-aop.xsd
       http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd
       http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">

    <!--开启组件扫描-->
    <context:component-scan base-package="com.crj.spring6.aop.xmlaop"></context:component-scan>

    <!--配置AOP的五种通知类型-->
    <aop:config>
        <!--配置切面类-->
        <aop:aspect ref="logAspect">
            <!--配置切入点-->
            <aop:pointcut id="pointcut" expression="execution(* com.crj.spring6.aop.annotationAop.CalculatorImpl.*(..))"/>
            <!--配置五种通知类型-->
            <!--前置-->
            <aop:before method="beforeMethod" pointcut-ref="pointcut"></aop:before>
            <!--后置-->
            <aop:after method="aroundMethod" pointcut-ref="pointcut"></aop:after>
            <!--返回-->
            <aop:after-returning method="afterReturnMethods" returning="result" pointcut-ref="pointcut"></aop:after-returning>
            <!--异常-->
            <aop:after-throwing method="afterThrowingMethod" throwing="ex" pointcut-ref="pointcut"></aop:after-throwing>
            <!--环绕-->
            <aop:around method="aroundMethod" pointcut-ref="pointcut"></aop:around>
        </aop:aspect>
    </aop:config>
</beans>

总结

        哈哈，学到这里荔枝总算把最最重要的部分学完了，马上就可以上手项目实操了，真实有点迫不及待呢哈哈哈哈哈哈~~~希望荔枝梳理的会对有需要的小伙伴有帮助，接下来荔枝可能会继续学习和梳理并总结产出，在暑假结束后荔枝也会对项目进行总结和复盘，希望那时的荔枝会离大佬更进一步哈哈哈哈哈哈。

今朝已然成为过去，明日依然向往未来！我是小荔枝，在技术成长的路上与你相伴，码文不易，麻烦举起小爪爪点个赞吧哈哈哈~~~ 比心心♥~~~

荔枝当大佬
关注
专栏目录
Spring中AOP实现（AOP的细致解析）
qq_74329022的博客
04-23 2152
AOP（Aspect-Oriented Programming，面向切面编程）是一种编程范式，它旨在通过将横切关注点（cross-cutting concerns）从应用程序的主要业务逻辑中分离出来，以提高代码的模块化性和可重用性。基于XML的AOP实现需要在Spring文件中配置大量的代码信息，不利于代码的阅读和维护，为了解决此问题，本实例将使用基于注解的方式实现AOP。创建ProductService（包com.j2ee.service）类，定义方法需要完成什么工作（如注册，登录，数据的增删改查的等）
演示spring AOP的切入表达式重用和优先级问题以及怎么实现基于xml的AOP
业精于勤，荒于嬉
08-08 955
本文详细的讲解了spring AOP的切入表达式重用和AOP优先级问题以及AOP怎么实现基于xml的aop😍Spring-AOP系类文章第一篇->Spring-AOP的基本介绍以及通过先动态代理方式实现第二篇->Spring-动态代理深入了解第三篇->再次分析-提出 Spring AOP-真正的AOP第四篇->spring-aop的切入表达式和JoinPoint的使用以及怎么返回通知获取结果和在异常通知中获取异常还有环绕通知😁热门专栏推荐想学习vue的可以看看这个java基础合集数据库合集。
Spring AOP——基于XML的AOP实现
m0_72151428的博客
09-29 1847
Spring AOP——基于XML的AOP实现
AOP-基于xml的实现
剑在手，跟我狗
04-28 361
AOP-基于xml的实现 我们在上几篇文章中实现了关于AOP基于注解的实现，在本文中，我们基于xml配置文件进行实现 首先我们补充一个知识点，下文能用到，Pointcut，定义和管理切入点。 @Pointcut(value ="execution(* com.yuyi.serviec.SomeserviceImpl.doSome())") private void myexe(){...
aop术语
weixin_33895657的博客
05-23 118
切面（Aspect）：一个关注点的模块化，这个关注点可能会横切多个对象。事务管理是J2EE应用中一个关于横切关注点的很好的例子。在SpringAOP中，切面可以使用基于模式）或者基于Aspect注解方式来实现。通俗点说就是我们加入的切面类（比如log类），可以这么理解。连接点（Joinpoint）：在程序执行过程中某个特定的点，比如某方法调用的时候或者处理异常的时候。在Sp...
Spring——面向切面编程(AOP)
行者无疆的博客
06-05 3748
本文介绍了切向切面编程(AOP)中的各个概念，并用两个案例分别讲解了如何通过注解和XML配置的方式使用AOP。
Spring框架——AOP面向切面编程
爱是与世界平行
10-13 746
简介 AOP练习 使用动态代理解决问题 Spring AOP 用AspectJ注解声明切面 前置后置通知 利用方法签名编写AspectJ切入点表达式 指定切面的优先级 基于XML的配置声明切面 Spring实例练习简介AOP（面向切面编程）：是一种新的方法论，是对传统OOP（面向对象编程）的补充。AOP编程时，仍然需要定义公共功能，但可以明确的定义这个功能在哪里，以什么方式应用，并且不必修改受影响的
【Spring篇】spring核心——AOP面向切面编程
m0_64231944的博客
11-26 1063
在我开始接触java框架知识后，我发现所谓的java框架就是把原本的一个整体分成了一小块一小块的部分，有种模块化思想，就是将分工变得更加明确，专业的人负责专门的事，让程序员更加专注于业务本身，将什么事务操作、日志操作抽取出去，模块化成一个小整体去专门负责做，然后将这个小整体做好后，像堆积木一样堆到事务该出现的位置，然后让一块一块的小积木堆成一个搭积；七点来讲述和帮助理解java框架思想Spring有两个极其重要的核心概念，一个是IOC/DI，另一个就是AOP。呢么什么是AOP呢？
spring——AOP面向切面编程（转载）
小白龙白龙马的博客
04-19 260
除了控制反转(IoC)和依赖注入(DI)外，Spring 框架还提供了对面向切面编程(AOP)的支持。本节，我们就对 AOP 面向切面编程进行讲解。AOP 的全称是“Aspect Oriented Programming”，译为“面向切面编程”，和 OOP(面向对象编程)类似，它也是一种编程思想。 图1：应用模块的划分 通常情况下，我们会根据业务使用 OOP(面向对象)思想，将应用划分为多个不同...
Spring Aop面向切面的java代码
05-23
Spring AOP，全称Spring面向切面编程，是Spring框架中的一个重要组成部分，它提供了一种在不修改原有代码的情况下，对程序进行功能增强的技术。面向切面编程（Aspect Oriented Programming，AOP）的核心思想是将关注...
Spring AOP——Spring 中面向切面编程
slw213106的博客
12-12 282
一、AOP——另一种编程思想 1.1 什么是 AOP AOP （Aspect Orient Programming）,直译过来就是 面向切面编程。AOP 是一种编程思想，是面向对象编程（OOP）的一种补充。面向对象编程将程序抽象成各个层次的对象，而面向切面编程是将程序抽象成各个切面。 从《Spring实战（第4版）》图书中扒了一张图： 从该图可以很形象地看出，所谓切面，相当于应用对象间的横切点，我们可以将其单独抽象为单独的模块。 1.2 为什么需要 AOP 想象下面的场景，开发中在多个模块间有
Spring Boot 学习和使用
cesske的博客
09-24 1089
Spring Boot是一款开源的Java Web应用框架，旨在简化Spring应用的初始搭建以及开发过程。Spring Boot通过整合Spring技术栈中的诸多关键组件，为开发者提供了一种快速、简便的Spring应用开发方式。它遵循“约定优于配置”的原则，通过自动配置、起步依赖和内置的Servlet容器，极大地简化了传统Spring应用的配置和部署过程。Spring Boot通过其自动化配置、起步依赖、内嵌服务器等特性，极大地简化了Spring应用的开发和部署过程。
工厂模式的介绍及实现
户伟伟的博客
09-25 116
工厂模式（Factory Pattern）是一种创建型设计模式，提供了一种创建对象的接口，而无需显式指定对象的具体类。在这种模式中，我们通过定义一个工厂类，专门负责生产各种类型的对象，这样我们可以避免直接在代码中实例化具体类，使代码更具扩展性、灵活性和维护性。解耦：客户端代码与具体的类解耦，避免了对象创建逻辑的重复。简化对象创建：通过工厂统一管理对象的创建逻辑，使代码更清晰易懂。扩展性强：新增类时，只需在工厂中增加创建逻辑，而不必修改现有的业务代码。
基于Hive和Hadoop的哔哩哔哩网站分析系统
最新发布
图南的博客
09-27 429
本项目是一个基于大数据技术的哔哩哔哩平台分析系统，旨在为用户提供全面的哔哩哔哩视频数据和深入的用户行为分析。系统采用 Hadoop 平台进行大规模数据存储和处理，利用 MapReduce 进行数据分析和处理，通过 Sqoop 实现数据的导入导出，以 Spark 为核心进行高效的数据处理。整个系统结合了大数据处理技术，为用户提供精准的内容推荐和深入的用户兴趣分析，帮助平台更好地了解视频趋势和用户需求。
智能BI平台项目
2302_79400545的博客
09-22 238
BI商业智能：数据可视化、报表可视化系统。
基于JavaWeb开发的Java+SpringMvc+vue+element实现驾校管理系统详细设计
央顺科技官方博客
09-24 906
机遇与挑战始终并存。在开放的互联网平台面前，驾校预约管理系统的信息管理面临着巨大的挑战。传统的管理模式局限于简单数据的管理，无法适应不断变化的市场格局。在早期阶段，在将计算机技术和网络技术融入驾校预约管理系统数据管理方法之前，所有管理方式都通过人工操作完成了管理信息的。系统管理也都将通过计算机进行整体智能化操作，对于驾校预约管理系统所牵扯的管理及数据保存都是非常多的，举例像所有详细信息包括，管理员；首页、个人中心、学员管理、驾校教练管理、驾校车辆管理、预约管理、取消预约管理、驾校公告管理、系统管理。
Java Alibaba Druid 数据库连接池
miracle的专栏
09-24 744
在Java开发中，数据库连接池是性能优化的重要一环。而作为一款强大的数据库连接池解决方案，凭借其和对多种数据库的支持，成为了许多企业级应用的首选。本篇文章将介绍Druid的核心特性，并结合不同数据库的实际用法。
Spring AOP详解：面向切面编程的概念与优势
Spring的AOP（面向切面编程）是软件开发中的一个重要概念，它是对传统面向对象编程（OOP）的补充。AOP的核心思想是将关注点分离，使得系统中的横切关注点（如日志记录、事务管理、性能监控等）可以从核心业务逻辑中...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值