I've run into this exact issue before—Liquibase can be stubborn about picking up custom naming strategies if there's a mismatch in classpaths or version compatibility. Let's break down the likely problems and how to fix them:

Common Causes & Solutions #

1. Version Mismatch Between Liquibase and Hibernate Extension #

Your Liquibase Maven plugin is on version 3.4.1, but the liquibase-hibernate4 extension is 3.5—these versions need to be aligned. Mismatched versions often cause the Hibernate integration to fall back to default strategies.

Update your plugin to match the extension version:

<plugin>
    <groupId>org.liquibase</groupId>
    <artifactId>liquibase-maven-plugin</artifactId>
    <version>3.5.5</version> <!-- Match hibernate extension version -->
    <configuration>
        <!-- Keep your existing config here -->
    </configuration>
    <dependencies>
        <dependency>
            <groupId>org.liquibase.ext</groupId>
            <artifactId>liquibase-hibernate4</artifactId>
            <version>3.5</version>
        </dependency>
        <!-- Rest of your dependencies -->
    </dependencies>
</plugin>

2. Custom Strategy Class Isn't in Liquibase's Classpath #

Maven plugins run in their own classloader, which doesn't automatically include your project's compiled classes. That means Liquibase can't find your CustomImplicitNamingStrategy unless you explicitly add your project as a dependency to the plugin.

Add this to the <dependencies> section of your Liquibase plugin:

<dependency>
    <groupId>foo.bar</groupId> <!-- Your project's groupId -->
    <artifactId>your-project-artifact-id</artifactId> <!-- Your project's artifactId -->
    <version>${project.version}</version>
</dependency>

3. Fix Liquibase Properties File Format #

Your liquibase.properties uses & which is HTML escaping—this isn't needed in a properties file. Use regular & instead to avoid parsing issues:

referenceUrl=hibernate:spring:foo.bar.model?dialect=org.hibernate.dialect.Oracle10gDialect&hibernate.physical_naming_strategy=org.springframework.boot.orm.jpa.hibernate.SpringPhysicalNamingStrategy&hibernate.implicit_naming_strategy=foo.bar.CustomImplicitNamingStrategy

4. Verify Hibernate Version Compatibility #

Spring 4.1.7 (used in your dependencies) pairs with Hibernate 4.3.x. Ensure your hibernate-core version matches this to avoid compatibility gaps. Add a dependency management entry if needed:

<dependencyManagement>
    <dependencies>
        <dependency>
            <groupId>org.hibernate</groupId>
            <artifactId>hibernate-core</artifactId>
            <version>4.3.11.Final</version> <!-- Matches Spring 4.1.7 -->
        </dependency>
    </dependencies>
</dependencyManagement>

5. Debug to Confirm Strategy is Loaded #

Add logging to your custom strategy to check if it's even being called by Liquibase:

@Component
public class CustomImplicitNamingStrategy extends SpringImplicitNamingStrategy {
    private static final Logger log = LoggerFactory.getLogger(CustomImplicitNamingStrategy.class);

    @Override
    public Identifier determineForeignKeyName(ImplicitForeignKeyNameSource source) {
        log.info("Custom foreign key strategy triggered!");
        Identifier userProvidedIdentifier = source.getUserProvidedIdentifier();
        if (userProvidedIdentifier != null) {
            return userProvidedIdentifier;
        }
        String foreignKey = String.format("FK_%s_%s", source.getTableName().getText(), source.getReferencedTableName().getText());
        log.info("Generated foreign key name: {}", foreignKey);
        return Identifier.toIdentifier(foreignKey);
    }
}

Run your Liquibase diff command and check the logs—if you don't see these messages, the class isn't being loaded (go back to step 2).

Final Checks #

• Double-check the full class name in your configs (foo.bar.CustomImplicitNamingStrategy)—typos are easy to miss!
• Ensure your physical naming strategy (SpringPhysicalNamingStrategy) isn't overriding your custom foreign key names.

内容的提问来源于stack exchange，提问作者Ben