Is there a tool like jenv, in favor of manage multiple mvn versions(installations)? the problem is that the first version was developed with mvn 3.0.5 and the second version will be develop with mvn 3.3 so when we compile with a on the command line it shows some mvn methods undefined.
Looking for the solution, i found the mvnvm project, it should manage the maven version using the property file mvnvm.properties an set it to an specific version:
$ cat mvnvm.properties
mvn_version=3.0.5
Related
I have a project which is written in java 8. It is kind of complex for me and very dependent to java 8. However I also happen to have a SonarQube and a Jenkins instance which is trying to use java 11 to scan the projects.
When java 11 is used to run:
mvn clean verify
I get java 8 dependency errors in the project and when I use java 8 I can not use sonarscanner.
I could not find and answer yet.
Any solution or suggestions ?
You can use your Jenkins instance (using JDK8) to build and submit the project to your SonarQube instance running on JDK11.
Using SonarQube's recommended scanner you can configure your project to use the remote SQ server:
pom.xml
<properties>
<sonar.host.url>https://sonarqube.cldbz.net/</sonar.host.url>
<sonar.junit.reportsPath>target/surefire-reports</sonar.junit.reportsPath>
<sonar.jacoco.reportPath>target/jacoco.exec</sonar.jacoco.reportPath>
<sonar.sources>src/main</sonar.sources>
</properties>
and then trigger the scanning process on Jenkins with mvn sonar:sonar which would submit your project's scan results to your SQ server.
You can even test this without pom.xml changes:
mvn clean verify sonar:sonar -Dsonar.login=<token> -Dsonar.host.url=https://<sonar-server>:<port>.
i am new to java and have mainly used node.js for most of my projects. I have used npm and used the npm install function to download packages. In maven, is there a similar function that easily installs packages?
mvn dependency:resolve
Is worth take a look to mvn life cycles
There's also mvn dependency:go-offline to download the dependencies and prepare to run the rest of the tasks without any connection to the internet.
I was looking for a way to install maven dependencies during a CI job, while explicitly NOT compiling the code or running the tests.
Keep all the dependencies in your pom.xml(You can think of this as package.json). If you are using an IDE like eclipse it will automatically download the dependencies for you. If you want to download the dependencies from the command line run mvn install.
You can find the corresponding XML for dependencies here https://mvnrepository.com/
Maven doesn't have an install command. Before any task you run maven checks if the project was changed and downloads any new dependency you specified from Maven Central repository.
EDIT: Maven calls the resolver for most tasks you run.
I'm working with multiple projects in Eclipse. because I want to automate the building I want to script the building process.
Unfortunately I cannot do the same actions on the commandline as in Eclipse.
So a common problem is that when a new function from a referenced project is used, I cannot build the project on the commandline with mvn. I use the command:
mvn clean install -U
But this command will give a build failure until I do a Eclipse Maven Update from the eclipse GUI. After that I can build the project again.
I also tried all the other commands I came across Stackoverflow:
mvn eclipse:eclipse
mvn dependency:resolve
So I just want to that Maven Update command in eclipse from the commandline so I can build from the commandline. If anyone could tell me what I'm doing wrong that would be awesome.
Thx in advance
Update for more clarification:
The project structure is:
Rest-service, Framework-service, Framework-model
Framework-model is referenced in the pom file by Framework-service and Framework-service is referenced by Rest-service. The other projects are not relevant to the problem.
When a function is added to Framework-model and used in Rest-service it gives an compilation error in eclipse and when I build with mvn clean install -U, although Maven install in eclipse is succesful but I think it is still using the old compiled code. After a Maven Update command in eclipse the compilation error is gone. And mvn clean install -U from the commandline also works.
How could I do a Maven Update command in the commandline? If mvn clean install -U should also do a Maven Update command, what settings should I check?
Another update: So this weekend I tried different things and running mvn compile before the mvn clean install -U command gives a different output. And finds the new function. But as I read maven, I thought install should also do the previous steps. How is this possible?
Eclipse's Maven plugin uses the maven version configured in Preferences/Maven/User settings. If you have a different version of maven in your Eclipse's settings than the one on your PATH variable, you could have different outputs. Maybe try and check that.
When I created a Spring Boot application I could see mvnw and mvnw.cmd files in the root of the project. What is the purpose of these two files?
These files are from Maven wrapper. It works similarly to the Gradle wrapper.
This allows you to run the Maven project without having Maven installed and present on the path. It downloads the correct Maven version if it's not found (as far as I know by default in your user home directory).
The mvnw file is for Linux (bash) and the mvnw.cmd is for the Windows environment.
To create or update all necessary Maven Wrapper files execute the following command:
mvn -N io.takari:maven:wrapper
To use a different version of maven you can specify the version as follows:
mvn -N io.takari:maven:wrapper -Dmaven=3.3.3
Both commands require maven on PATH (add the path to maven bin to Path on System Variables) if you already have mvnw in your project you can use ./mvnw instead of mvn in the commands.
Command mvnw uses Maven that is by default downloaded to ~/.m2/wrapper on the first use.
URL with Maven is specified in each project at .mvn/wrapper/maven-wrapper.properties:
distributionUrl=https://repo1.maven.org/maven2/org/apache/maven/apache-maven/3.3.9/apache-maven-3.3.9-bin.zip
To update or change Maven version invoke the following (remember about --non-recursive for multi-module projects):
./mvnw io.takari:maven:wrapper -Dmaven=3.3.9
or just modify .mvn/wrapper/maven-wrapper.properties manually.
To generate wrapper from scratch using Maven (you need to have it already in PATH run:
mvn io.takari:maven:wrapper -Dmaven=3.3.9
The Maven Wrapper is an excellent choice for projects that need a specific version of Maven (or for users that don't want to install Maven at all). Instead of installing many versions of it in the operating system, we can just use the project-specific wrapper script.
mvnw: it's an executable Unix shell script used in place of a fully installed Maven
mvnw.cmd: it's for Windows environment
Use Cases
The wrapper should work with different operating systems such as:
Linux
OSX
Windows
Solaris
After that, we can run our goals like this for the Unix system:
./mvnw clean install
And the following command for Batch:
./mvnw.cmd clean install
If we don't have the specified Maven in the wrapper properties, it'll be downloaded and installed in the folder $USER_HOME/.m2/wrapper/dists of the system.
Maven Wrapper plugin
Maven Wrapper plugin to make auto installation in a simple Spring Boot project.
First, we need to go in the main folder of the project and run this command:
mvn -N io.takari:maven:wrapper
We can also specify the version of Maven:
mvn -N io.takari:maven:wrapper -Dmaven=3.5.2
The option -N means –non-recursive so that the wrapper will only be applied to the main project of the current directory, not in any submodules.
Source 1 (further reading): https://www.baeldung.com/maven-wrapper
short answer: to run Maven and Gradle in the terminal without following manual installation processes.
Gradle example:
./gradlew clean build
./gradlew bootRun
Maven example:
./mvnw clean install
./mvnw spring-boot:run
"The recommended way to execute any Gradle build is with the help of the Gradle Wrapper (in short just “Wrapper”). The Wrapper is a script that invokes a declared version of Gradle, downloading it beforehand if necessary. As a result, developers can get up and running with a Gradle project quickly without having to follow manual installation processes saving your company time and money."
Gradle would also add some specific files corresponding to the Maven files Gradlew and Gradle.bat
In the windows OS, mvnw clean install is used for the maven clean and install activity, and mvnw spring-boot:run is used to run the Spring boot application from Command Prompt.
For Eaxmple:
C:\SamplesSpringBoot\demo>mvnw clean install
C:\SamplesSpringBoot\demo>mvnw spring-boot:run
By far the best option nowadays would be using a maven container as a builder tool. A mvn.sh script like this would be enough:
#!/bin/bash
docker run --rm -ti \
-v $(pwd):/opt/app \
-w /opt/app \
-e TERM=xterm \
-v $HOME/.m2:/root/.m2 \
maven mvn "$#"
In our company we use a patched maven3 which replaces
a <version>${com.foo.bar.version}</version> placeholder with a real version before doing all the maven stuff. Might not be a great ideas, but I can not change this fact.
All works fine with command line mvn commands.
In IntelliJ I have set maven home dir to the correct location of the patched maven.
But right click->maven->reimport does not work.
In the module settings I see that the dependencies of my module have wrong versions.
Is right click->maven->reimport using mvn dependency:tree of the patched maven? Or does IntelliJ uses some own implementation?
Following is from the console in IntelliJ's maven projects install goal
/System/Library/Java/JavaVirtualMachines/1.6.0.jdk/Contents/Home/bin/java -Dmaven.home=/usr/share/java/patched/maven-3.0.3 -Dclassworlds.conf=/usr/share/java/patched/maven-3.0.3/bin/m2.conf -Didea.launcher.port=7536 "-Didea.launcher.bin.path=/Applications/IntelliJ IDEA 13 CE.app/bin" -Dfile.encoding=UTF-8 -classpath "/usr/share/java/maven-3.0.3/boot/plexus-classworlds-2.4.jar:/Applications/IntelliJ IDEA 13 CE.app/lib/idea_rt.jar" com.intellij.rt.execution.application.AppMain org.codehaus.classworlds.Launcher install
Does this mean it uses a java maven implementation in /usr/share/java/maven-3.0.3/boot/plexus-classworlds-2.4.jar and not the maven executable in the path to our patched maven ?
B.t.w I found out, that version-variables <version>${com.foo.bar.version}</version> are ok, they just not possible in the parent/reactor pom
I won't even ask why it was necessary to use a "patched" maven (it seems like a very bad idea), but in any case: I am reasonably confident that intellij is using it's own in-memory dependency analysis when you invoke the reimport action.
Perhaps you are best to use a maven profile that sets the correct version for your development environment and build with -Pmyprofile.