I am learning to create a java ee web application. In intellij idea I created a project using the project wizard: Java Enterprise -> Web Application. Then I created a build file.gradle in the project root, and call the gradle init, gradle build in the terminal. Here is the build file.gradle
apply plugin: 'java'
apply plugin: 'war'
apply plugin: 'idea'
repositories {
jcenter()
mavenCentral()
}
sourceCompatibility = 1.5
dependencies {
compile 'org.slf4j:slf4j-api:1.7.21'
compile 'com.squareup.retrofit2:converter-gson:2.0.2'
testCompile 'junit:junit:4.12'
}
When I add a dependency and do gradle build, they are not loaded into the project. For example, the Gson library is not available in the code. How to tell Gradle to download the libraries so I could use them? What i'm doing wrong?
IntelliJ's Gradle integration does not automatically reflect changes you make in your build script. You will have manually initiate the synchronization between build script and IntelliJ project.
Your project is not backed by gradle. The easiest way for me to fix this is to :
close and re-open the project;
the bottom-right of the screen should display (x) Event log (the digit in parentheses being the number of events raised);
click on Event log;
a tooltip pops up, click on Import Gradle project;
a window pops up, configure gradle options.
When your run gradle build does it shows the dependency downloading, if so then the dependency has downloaded but not avaialable in intellij
Quick fix is to close the project
Remove the .idea folder and the .iml file
Next re-open your intellij
Click on File -> choose New -> Project From Existing Source
Select your project build.gradle
Allow Intellij to do the rest
Related
I have a very basic java project.
In Eclipse there is an option to convert a project to a maven project all you have to do is right click on the java project and click "Convert to Maven Project". So basically it creates a pom.xml file for you.
Does IntelliJ have a similar command to convert to Gradle? Searched around but it did not seem like it does.
The simple way to migrate from Maven to Gradle via Intellij IDEA is:
Install Gradle Build Tool from https://gradle.org/
Add Path to System Enviroments (like in Gradle instructions)
Open your Maven project in Intellij IDEA and then open "Terminal" tab.
Write gradle init. Wait until the building process ends and then save & close your project.
Reopen your project and click Auto-import, and wait while Gradle is running. Approximate time - 5 mins.
Close your project (you may want to commit first)
Select "New Project"
Select Gradle (and any other frameworks you need)
Enter the directory where the Idea project to be converted is and
click "Finish"
Idea should handle the rest, you may need to move your files into main/java (etc)
I don't think there's a simple way to do this in place.
Convert a regular project into a Gradle project
Open your project in IntelliJ IDEA.
Create a build.gradle file. Add the information you need.
example:
plugins {
id 'java'
}
group 'org.example'
version '1.0-SNAPSHOT'
repositories {
mavenCentral()
}
dependencies {
testImplementation 'org.junit.jupiter:junit-jupiter-api:5.8.2'
}
As soon as you create a build.gradle file, IntelliJ IDEA recognizes the Gradle build script and displays a notification suggesting to load the project as Gradle. After you load the project, IntelliJ IDEA enables the Gradle tool window.
From: https://www.jetbrains.com/help/idea/gradle.html#convert_project_to_gradle
I want to create a simple java servlet in intellij IDEA.
I saw this page about how to do so,
But how can I make this web-project also a gradle project?
I want to evolve my servlet and add dependencies
I want to runt he servlet later and be able to debug it with breakpoints
First use IntelliJ to create a new Gradle Project. Second create a standard project structure for a webapp like:
src/main/java/yourPackage/yourServlet.java
src/main/webapp/WEB-INF/web.xml
src/main/webapp/index.html
Add the following to your gradle.build file:
apply plugin: 'jetty'
//also applies plugin: 'war'
//and this also applies plugin: 'java'
repositories{
mavenCentral()
}
dependencies {
compile 'javax.servlet:javax.servlet-api:3.1.0'
}
Now you can just build your project with the gradle (or gradlew if you use the wrapper) build task and run it with the jettyRun task. If you don't want to use jetty, you can use the war plugin without the jetty plugin and deploy your generated war file on every server you want. The war file will be located in projectRoot/build/libs
See also the user guide of gradle: Chapter 47. Web Application Quickstart
I a newbie in Gradle and trying to find my way around it but facing some issues that needs to be resolved before i can proceed my Gradle tutorials.
At the moment i have compiled the app from the command prompt and seems to be working.
The issues i have now is that i can't see the dependencies (spring libraries) that Gradle has downloaded in Eclipse. If i look into the "Project and External Dependencies" folder in eclipse under the Gradle project i have created, i can't see the spring libraries there. For instance in Maven, the moment you add a dependency and save the POM file, the dependencies are added to the library instantly. Because of this issue red-error-markers appear in the source codes that are using the spring libraries though the application runs perfect from the command line.
How do i fix this problem? Does Gradle put the libraries somewhere?
My buld.gradle file is
apply plugin: 'java'
apply plugin: 'application'
mainClassName = System.getProperty("mainClass")
repositories {
mavenCentral()
}
dependencies {
compile 'org.slf4j:slf4j-api:1.7.14'
testCompile 'junit:junit:4.12'
compile 'org.springframework:spring-context:4.0.5.RELEASE'
}
thanks.
Extra question :: is there a way to let Gradle run in eclipse so that the output of my application is displayed in the eclipse console?
I have the following project structure:
root-gradle (build.gradle)
project-group1 (no build file)
project1 (build.gradle)
project2 (build.gradle)
...
project-group2 (no build file)
...
So happens that I have to recreate Eclipse projects often. I run command:
gradle cleanEclipse eclipse
After a number of runs "eclipse" task stops working as expected. Namely, it does not add gradle nature to the projects anymore and does not recognize
sourceCompatibility = 1.6
anymore attempting to build everything with 1.8 version of Java.
I added the following to the root build.gradle:
allprojects {
sourceCompatibility = 1.6
eclipse.project {
natures 'org.springsource.ide.eclipse.gradle.core.nature'
}
// more stuff here ...
}
This helped with the root project, but had no effect on any other project.
I added the same thing to subprojects with the same unsatisfactory result.
I have to say than even after the nature had been added to the root project and Gradle plugin options became available for the root again I still don't see the "G" icon.
So it looks like I have 2 problems with the gradle setup.
Disappearance of the gradle nature. After a few runs Eclipse stops recognizing gradle projects. I wouldn't even face the second problem if that worked properly.
Some problem with my gradle build files or projects layout as my settings don't seem to take effect on subprojects.
Missing "G" icon for the project with restored Gradle nature.
Using the Buildship: Eclipse Plug-ins for Gradle I had to use natures string org.eclipse.buildship.core.gradleprojectnature
For Example:
allprojects {
eclipse.project {
natures 'org.eclipse.buildship.core.gradleprojectnature'
}
}
Install Gradle plug-in for Eclipse
Then use Eclipse menu: File -> Import... to import the Gradle project.
It will add the Gradle Nature. And 2 extra Eclipse views, one for quickly running Gradle tasks. One for Gradle output of those executed tasks.
TIP: Before importing an existing Gradle project, create a New Gradle project, to see if the Gradle plug-in is working as expected.
New Gradle Project
Use the Eclispe menu: File -> New -> Other...
Select the wizard: Gradle -> Gradle Project
Enter the project name
Press the button Finish
This should set up a minimal Gradle project.
If there is an evaluation phase race condition, you can eliminate it by using the afterEvaluate qualifier. I would try:
allprojects {
afterEvaluate {
eclipse.project {
natures 'org.springsource.ide.eclipse.gradle.core.nature'
}
}
}
I think you must set gradle to your system environment.
Steps:
Install Gradle from gradle website.
Go to eclipse preferences set Home path in gradle EnIDE like C:\gradle-2.3
or whatever directory you have installed.
Also make sure to add path to your system environment variable.
in the settings.gradle >>
include 'Device', 'Secugen', 'Morpho', 'NIDVSADesktop'
here NIDVSADesktop is my root project.
in the root project gradle
dependencies {
compile project(':Secugen')
compile project(':Morpho')
}
here Secugen and Morpho are my 2 sub projects
Remove Gradle Nature close ecllips then go to project folder structure and run the command "./gradlew clean build -x test cleanEclipse eclipse" next open eclipse and just refresh the project
I have an existing Java project in Eclipse. I want to implement builds using gradle. I tried using the gradle eclipse plugin as given here but ran into numerous errors in Eclipse.
I am using gradle 1.3, and I tried running gradle from command prompt, but I get compilation errors.
So my question is, does anyone know of some good resource which offers a how-to for converting an existing java project in Eclipse to compile using gradle. I also have some dependencies on other projects. The link to the tutorial I have given is not really helpful.
UPDATE:
I can get gradle to work if my project doesn't have dependencies on other projects. However, if it does refer to some other project, I can't figure out how to reference another project? I have added the referenced project dir to repositories but I still get "class does not exist" errors. My gradle file is as below:
apply plugin: 'java'
apply plugin: 'eclipse'
version='1.0-SNAPSHOT'
def repositoryPath = 'C:/Users/AMoody/workspace/temp/temp-protocols/'
repositories{
mavenCentral()
flatDir {
dirs repositoryPath
}
}
dependencies{
compile 'org.slf4j:slf4j-api:1.+'
compile 'junit:junit:4.+'
testCompile 'junit:junit:4.+'
}
Okay, So if you have simple java project which has dir/file structure as below
Step-1: create file name build.gradle in project root directory as below
Step-2: add following gradle script in build.gradle
apply plugin: 'java'
apply plugin: 'eclipse'
archivesBaseName = 'someJar'
version = '1.0-SNAPSHOT'
repositories {
mavenCentral()
}
jar {
manifest {
attributes 'Main-Class': 'com.test.Run'
}
}
dependencies {
compile 'log4j:log4j:1.2.16'
}
Step-3: close or delete from eclipse this project and import it again while selecting Gradle project as below
Now your project hierarchy will look like this. (Also note its added Gradle Dependencies while importing project)
Step-4: Create source foler src/main/java in project and move your all packages in that source folder.
Step-5 last but not the least: Cheers :)
So now your Simple Java project has converted into Gradle project!
The first couple of chapters of the Gradle User Guide, along with the many (Java) samples in the full Gradle distribution, should get you started. It doesn't matter all that much whether your current build is Eclipse or something else; to be successful with Gradle, you'll first have to master its fundamentals.
Once you have the Gradle command line build working, you can give the IDE integration another shot. Depending on your preferences, you can either generate IDE files with Gradle's Eclipse plugin (again see the samples in the full Gradle distribution), or use the Eclipse Gradle Integration for a more integrated IDE experience.
Check out the Gradle homepage for additional resources. When faced with a concrete question about Gradle's build language, consult the Gradle DSL Reference. A full-text search over the single-page Gradle User Guide can also be quite effective. Last but not least, make sure to visit the Gradle Forums.
Try Eclipse integration for Gradle: http://marketplace.eclipse.org/content/buildship-gradle-integration