maven-dependency-plugin | Apache Maven Dependency Plugin | Plugin library

There exist multiple ways to add local jar files to a Maven project below I show you 2:

1.Adding directly the dependency as system scope:

Assuming that the JAR is located in /lib add the dependency in your pom.xml:

As mentioned here https://github.com/spring-projects/spring-boot/issues/25049#event-4265028906

I resolved the error by removing the under the build section of the pom.xml file. Seems like Heroku was not reading the , after removing it the app got successfully deployed to Heroku. I followed the following steps after removing the tag:

We have run into something like this before. There is a bug reported for the jar plugin that was not fixed. Luckily, there is a workaround. Adjust the manifest in the jar plugin like this:

If you run locally with an IDE like IntelliJ, it will handle things like this to you, but you need add a plugin to create a jar with dependencies before deploying it.

OK, I think I know what might be happening: Like I said in my comment:

I just read your message on the mailing list and tried in one of my own projects, also using plugin version 3.1.2. Actually, just specifying false inside the was enough to avoid overwriting. I just executed the unpack goal once, then manually modified an unpacked file and it did not get overwritten. I even see my-artifact-1.3.jar already unpacked in the log.

I continued experimenting some more and noticed that even when deleting many unpacked files, they will not be recreated, so the check must be on a more global level, not on a per-file basis.

Even when deleting all files or the whole output directory, the dependency will not be unpacked again. That was a sure indicator that some kind of meta information must be stored somewhere outside the output directory. The first place to look for it was of course the target directory, and obviously enough, in subdirectory target/dependency-maven-plugin-markers there are (empty) marker files like my-dependency-1.3.marker. Deleting one of those files has the effect of the dependency getting unpacked again during the next build, overwriting possible existing files.

So the way for you to solve this problem is to avoid cleaning the target directory or at making sure to keep the corresponding marker file.

Update: You could also create the marker file by yourself if the EXE file you want to protect exists and if for some reason your build workflow needs the clean in between. But the latter would be a bit ugly, you should try to avoid it. With Antrun or some Beanshell or Groovy scripting it would be possible, though.

Somewhat more elegant would be a profile with auto-activation if the EXE file does not exist, then putting the dependency plugin inside the profile, i.e. it would only get active if the EXE does not exist in the first place.

Solved with called this.accountModels = accountServices.getAccountTable(); on testAdd(). Thanks All! I appreciate to you.

Your problem has nothing whatsoever to do with NullPointerException. Your exception handling is bad, and you need to fix it, so that you don't get confused again.

Your exception handling scheme boils down to: "Print some information to standard out and just keep going". That last bit is the problem: Your code was not written with the notion that every line may simply do something, or nothing, depending on whether exceptions happen. Thus, your code keeps rolling and because things aren't in a state you expected, further errors occur, and these errors are completely irrelevant - they are not the problem, but they clog the logs and confuse you.

The right strategy to deal with exceptions is to deal with them. "Whatever, just print it out and keep on going" is not dealing with them. If you can't deal with them (and that's the common case), then just let the exception bubble up. Do not catch it unless you can write code that solves the problem. An exception that nothing can handle should bubble all the way up and roll up the thread, that's the best solution, and also the least code, so that's a win-win.

Methods that clearly are intended to interact with the database should be declared to throws SQLException, and your public static void main method should be declared to throws Exception, which is allowed.

If you somehow MUST catch a checked exception even if you don't know what to do (that's bad), then at least put; throw new RuntimeException("Unhandled", e); in your catch block, instead of `e.printStackTrace(System.out).

Your mysql driver is trying to load a corrupted keystore. That's a rather tricky problem.

Most likely you've added a configuration (or a default configuration is being applied) that expects a keystore file at C:\AppServers\glassfish5\glassfish\domains\domain1/config/keystore.jks - I don't think the problem is the mix of slashes (java usually understands this just fine), but I bet that file doesn't exist. Alternatively, you tried to make it, an exception occured, and the same deplorable exception handling has resulted in you not realizing that the keyfile is corrupt. Check the file - it's probably not there at all, or at 0 bytes. (Re)generate it, or fix the configuration.

This might have to do with you not using Generics with your java Collections