没有源码，如何修改代码逻辑？

来源：cnblogs　　作者：踩刀诗人　　时间：2025/3/7 9:17:02　　对本文有异议

拍摄于西安德福巷

前段时间接手了一个二次开发其他团队代码的项目，过程中发生了不少有意思的小插曲。今天正好有点空闲时间，就简单梳理一下，希望能给大家提供一些参考和帮助。

当我咨询对方团队：“大哥，我们这边要对你们在xxx项目上的代码进行二次开发，想了解下你们的二开机制是怎样的？”

对方回复道：“我们没有特别明确的二开机制。不过标品这边会提供jar包给你们，你们只需新建一个Spring Boot工程，然后通过依赖这个标品jar包来搭建二开工程。要是想修改业务逻辑，基于Spring的AOP机制进行操作就行，自由度还是比较高的。”

我听后有些惊讶：“原来是这样操作啊，我一开始还以为是从你们的代码仓库拉分支或者fork一份代码，然后我们在这个基础上进行修改呢。”

不得不说，基于AOP进行二次开发确实有很大的灵活性，开发者可以根据自己的需求自由发挥。但这种方式也存在明显的弊端，一旦项目出现问题，排查起来会比较困难。而且过度使用AOP，会导致业务逻辑分散在各个地方，不利于维护。回顾以往的开发经验，我使用AOP主要是进行一些横向的功能补充或扩展，比如权限控制、异常处理等方面，还真没试过用它来实现核心功能

接下来，正式进入今天的主题：在没有源码的情况下，怎样修改代码逻辑？

方式一：基于Spring AOP

至于AOP的基础概念我就不啰嗦了，请自行前往官网了解。通过一段简单代码来看下如何通过AOP来修改代码逻辑：

import jakarta.annotation.Resource;
import org.springframework.stereotype.Service;
 
@Service
public class BizService {
     //原有逻辑
    public void testBiz(){
        System.out.println("testBiz");
    }
}
 
通过切面修改BizService的testBiz逻辑
 
@Aspect
@Component
public class BizAspectTest {
    //Around切面拦截BizService的testBiz方法
    @Around("execution(* com.example.demo.BizService.testBiz())")
    public void around(ProceedingJoinPoint joinPoint) throws Throwable {
        System.out.println("around");
        //继续原逻辑。如果想完全修改，也可以不继续
        joinPoint.proceed();
    }
}

到这里，我们成功修改了 BizService 的 testBiz 方法逻辑，却没有对 BizService 的代码做任何改动。

一切看似风平浪静，可不出意外的话，新问题马上就要接踵而至了。

方式二：类覆盖

方式一基于Spring 的AOP机制来做逻辑的更改，前提是技术框架基于Spring，且Bean的生命周期还必须交给Spring托管才可以，如果是直接new出来的Bean，AOP也无能为力，比如：

public class BizService2 {
    public void testBiz(){
        System.out.println("testBiz in BizService2");
    }
}
 
BizService2 bizService2 = new BizService2();
bizService2.testBiz()

遇到这种情况该如何处理呢？起初，我想到的办法是在自己的二开工程里定义一个与原类同名的 BizService2 。接着，把需要修改的代码复制过来，针对要二次开发的部分进行调整。倘若我们要修改的 BizService2 位于 biz.jar 中，那么就在这个二次开发工程内，定义一个类路径与原类完全一致的 BizService2 ，如此一来，便可以按照需求自由编写代码了。其实，这里运用的是Spring Boot类加载机制的顺序原理，通过这种方式巧妙地实现了代码的定制化修改。

Spring Boot 使用 LaunchedURLClassLoader 来加载类，该类加载器在加载类时会按照一定的顺序搜索类路径。在搜索过程中，会先从 BOOT-INF/classes 目录查找所需的类，如果在该目录下找到了对应的类文件，就会直接加载该类，而不会再去 BOOT-INF/lib 目录下的 JAR 文件中查找同名类。（来源于网络）

不难发现，这种方法简单直接，弊端也很明显，会留下大量冗余代码。就算仅仅是修改一行代码，也不得不把其余代码都保留下来，这无疑增加了后续维护的难度和成本。既然这种方式存在不足，那么接下来，就让我们一起看看方法三，说不定能找到更优解。

方式三：Mojo's AspectJ Maven Plugin

这是一个Maven的插件，可以在编译期对代码进行植入，和Spring AOP的最终效果类似，Spring AOP是运行时植入，而它是编译时植入，第一次知道它的时候确实让我眼前一亮，以植入BizService2为例看看怎么操作：

//1.依然定义切面类，语法和使用Spring AOP时一样
@Aspect
public class BizAspect2Test {
    //Around切面拦截BizService的testBiz方法
    @Around("execution(* com.example.demo.BizService2.testBiz())")
    public void around(ProceedingJoinPoint joinPoint) throws Throwable {
        System.out.println("around");
        joinPoint.proceed();
    }
}
 
//2.配置maven插件
<build>
  <plugins>
    <plugin>
      <groupId>org.codehaus.mojo</groupId>
      <artifactId>aspectj-maven-plugin</artifactId>
      <version>1.15.0</version>
      <configuration>
        <complianceLevel>16</complianceLevel>
        <source>16</source>
        <showWeaveInfo>true</showWeaveInfo>
        <!--如果要植入的类在jar包内，一定要这里指定-->
        <weaveDependencies>
          <weaveDependency>
            <groupId>com.xxx</groupId>
            <artifactId>yyy</artifactId>
          </weaveDependency>
        </weaveDependencies>
      </configuration>
      <executions>
        <execution>
          <configuration>
            <skip>false</skip>
          </configuration>
          <goals>
            <goal>compile</goal>
          </goals>
        </execution>
      </executions>
    </plugin>
  </plugins>
</build>
 
//3.引入aspectjrt
<dependency>
  <groupId>org.aspectj</groupId>
  <artifactId>aspectjrt</artifactId>
  <version>1.9.19</version>
</dependency>

接下来就是使用maven正常编译，看看编译以后BizService2会发生什么变化，我们反编译BizService2看看：

import com.example.demo.BizAspect2Test;
import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.Signature;
import org.aspectj.runtime.reflect.Factory;
public class BizService2 {
    private static /* synthetic */ JoinPoint.StaticPart ajc$tjp_0;
    static {
        // 1
        BizService2.ajc$preClinit();
    }
    public void testBiz() {
        // 1
        JoinPoint joinPoint = Factory.makeJP(ajc$tjp_0, this, this);
        BizService2.testBiz_aroundBody1$advice(this, joinPoint, BizAspect2Test.aspectOf(), (ProceedingJoinPoint) joinPoint);
    }
    private static /* synthetic */ void ajc$preClinit() {
        Factory factory = new Factory("BizService2.java", BizService2.class);
        ajc$tjp_0 = factory.makeSJP("method-execution", (Signature) factory.makeMethodSig("1", "testBiz", "com.example.demo.BizService2", "", "", "", "void"), 4);
    }
    private static final /* synthetic */ void testBiz_aroundBody1$advice(BizService2 ajc$this, JoinPoint thisJoinPoint, BizAspect2Test ajc$aspectInstance, ProceedingJoinPoint joinPoint) {
        // 13
        System.out.println("around");
        // 14
        ProceedingJoinPoint proceedingJoinPoint = joinPoint;
        System.out.println("testBiz in BizService2");
    }
}

可以看到BizServer2内部已经融合了BizAspect2Test的相关逻辑，是不是很强大。最后借助豆包的回答来看看aspectjrt和Spring AOP实现原理的对比：

aspectjrt

AspectJ 采用了编译时织入（Compile-time weaving）、加载时织入（Load-time weaving）等方式。编译时织入是在 Java 源代码编译成字节码的过程中，就将切面逻辑合并到目标类的字节码中；加载时织入则是在类加载到 JVM 时，通过特殊的类加载器对字节码进行修改，插入切面逻辑。
这种方式生成的代码在运行时没有额外的性能开销，因为切面逻辑已经成为目标类的一部分。

Spring AOP

Spring AOP 主要基于代理模式实现，分为 JDK 动态代理和 CGLIB 代理。当目标对象实现了接口时，使用 JDK 动态代理；当目标对象没有实现接口时，使用 CGLIB 代理。
代理模式在运行时创建代理对象，通过代理对象来调用目标对象的方法，并在方法调用前后插入切面逻辑。因此，在运行时会有一定的性能开销，尤其是在频繁调用方法时。

方式一：基于Spring AOP

方式二：类覆盖

方式三：Mojo's AspectJ Maven Plugin

推荐阅读

编程经验热门文章

编程经验推荐文章