Once you have the above items installed, proceed to the next step.<\/p>\n
3. Creating the project<\/h2>\n
To create the project, go to the File menu and select New Project. It opens up a New Project panel as shown below. Select the project category – Java Web and Project type as Web application to begin with. <\/p>\n Enter the project name and select the path to store your project as shown in the below image and click Next<\/p>\n In the next screen, select your server to be Glassfish server and Java version to be Java EE 7 or Java EE 8. The Context path can be kept as it is. The context path decides your local URL path. <\/p>\n In the final screen, you should see the selection of framework. Netbeans support various frameworks starter projects out of the box. Spring Framework is one of them. In the frameworks selection screen, select Java Spring Framework. You can choose the latest version here. As of present day, we have Spring 4.0.1 version available out of the box in Netbeans. Choose the version and click finish to create the initial project. It might take some time if the framework was not downloaded before. <\/p>\n Now that you have created the first Spring Web MVC project, let us run it. To run the project, run project option in the image shown below. The option will perform two operations. <\/p>\n The Glassfish server will automatically open the home page. The default page will contain simple text mentioning that it is a default page and guide you through how to make changes.<\/p>\n The project created by Netbeans shows four main folders in the projects window. The folders are:<\/p>\n This organized folder structure of Netbeans is a great benefit. It is self explanatory as to which files are contained in the folders. A brief description of each of the folders is discussed below.<\/p>\n The web pages folder contain the WEB-INF directory which holds the web related configuration files and the jsp files which are to be served to the user. The Source packages is the place where all your Spring Controllers, Beans and related java files will be placed. The Libraries folder is the collection of all the dependencies. It contains the jar files of the relevant libraries that are required for the Spring Web MVC application. Any additional library that you use can be added to libraries folder. The last is Configuration Files contain the configuration files for the Spring Web MVC application. This includes web.xml again as it is also a configuration file for the Web servlet configuration. <\/p>\n You might not always require a Web MVC project and might be looking to create a project from scratch with only the required dependencies. In order to do so, we need to manually create either a Dynamic Web project or a Java project depending on the type of project we need. Later, we need to add the Spring dependencies to it. Let us go through the process of creating the same. <\/p>\n We will go through the process of creating a Spring Core project. To create one, navigate to New Project. Select Java Application as the type of project and click next. Name the project as SpringCoreApp. You will see a simple project created with just two folders – Source packages and Libraries. <\/p>\n The first step towards configuring a Spring Core project is to add its libraries. You can download the Spring Core<\/a> and Spring Context<\/a> jar files from the links and save them. To add the jars to the libraries, right click the project and select project properties. <\/p>\n In the project properties select Libraries as shown in the image above. Click Add jar and select the jars that you have downloaded and click OK. You should see the files in libraries section now. You now have the base dependencies for the Spring project. Let us begin creating the configuration file and a basic bean to start our project. <\/p>\n In this tutorial, we will be using the Java based Spring framework configuration to create our Spring Core Application. To start with the same, we first need to create a Spring Bean. The Spring bean with Java configuration can be created by just annotating it with Let us create our first bean.<\/p>\n HelloJava.java<\/em><\/span><\/p>\n The above file provides a class which has an attribute in it. Now let us configure Spring to provide this as a bean. To create the Spring configuration file, use the below code. <\/p>\n HelloSpringConfig.java<\/em><\/span><\/p>\n Notice two annotations in the above code. These annotations are the primary annotations for the Java configuration in Spring Core application. The annotation To start the project, we need to update the main function in the class <code>SpringCoreApp<\/code> that was created by default. In case you gave a different name to the project, the class might differ. Update the class to contain the below code. <\/p>\n SpringCoreApp.java<\/em><\/span><\/p>\n The above code does the job of starting the Spring application and load its configuration files. Let us understand the SpringCoreApp.java<\/em><\/span><\/p>\n Now that we have all the things in place, let us actually execute the code and see the output. As soon as you run the code, you will hit a roadblock with the below error. <\/p>\n Although there was no failures in compilation, it gave this error. The reason behind the error is that in the background spring is dependent on other jars too which need to be added. Spring is a modularised framework and we need to put together all the dependent modules to get it to work. Download the Apache Commons Loggging<\/a> jar and all the Spring framework dependencies from this link.<\/a> Download the dist archive. From the dist archive, add all the release jars into the dependencies for the project. Once that is done, run the project. You should not see any error. The output of the project should be similar to the one shown below.<\/p>\n The application runs perfectly alright and is able to get the bean and use it. There are chances where you might need to use multiple configuration files. Let us discuss the same in the next section. <\/p>\n Before understanding how to use multiple configuration files, let us create another bean and another configuration file. The code for the files is given below.<\/p>\n HelloSecondTime.java<\/em><\/span><\/p>\n HelloSecondConfig.java<\/em><\/span><\/p>\n Now that we have two configuration files configuring different beans, we can modify our code in the main function to utilise these two configuration files. To do so, update the code inside the function as shown below.<\/p>\n SpringCoreApp.java<\/em><\/span><\/p>\n Execute the code with the two configuration files registered in the main function. The code should now be able to read the two configuration files and progress on the same. On executing the code, you should be seeing an output similar to the one shown below. <\/p>\n run: Thus, we built a spring core application using multiple configuration file and having multiple beans. <\/p>\n Building a Spring App using Netbeans is quite easy as long as you understand the basic about the Spring framework. In this tutorial, we captured the process of building a Spring Web MVC app as well as Spring Core application from scratch. Further coding can easily be done on top of these just like any other Spring application. The code or imports might change with the future versions of Spring framework. Hence, you need to ensure that you are using the right version of Spring framework at any point of time. <\/p>\n The code files of the project created above are packaged in an archive and provided at the below link.<\/p>\n![\"Spring](\"http:\/\/examples.javacodegeeks.com\/wp-content\/uploads\/2019\/05\/1.jpeg\")
![\"Spring](\"http:\/\/examples.javacodegeeks.com\/wp-content\/uploads\/2019\/05\/2.jpeg\")
![\"Spring](\"http:\/\/examples.javacodegeeks.com\/wp-content\/uploads\/2019\/05\/4.jpeg\")
![\"Spring](\"http:\/\/examples.javacodegeeks.com\/wp-content\/uploads\/2019\/05\/3.jpeg\")
4. Run your project first time<\/h2>\n
\n
![\"Spring](\"http:\/\/examples.javacodegeeks.com\/wp-content\/uploads\/2019\/05\/5.jpeg\")
5. Understanding the project structure<\/h2>\n
\n
6. Creating a project from scratch<\/h2>\n
![\"Spring](\"http:\/\/examples.javacodegeeks.com\/wp-content\/uploads\/2019\/05\/6.jpeg\")
![\"Spring](\"http:\/\/examples.javacodegeeks.com\/wp-content\/uploads\/2019\/05\/7.jpeg\")
![\"Spring](\"https:\/\/examples.javacodegeeks.com\/wp-content\/uploads\/2019\/05\/8.jpeg\")
![\"Spring](\"http:\/\/examples.javacodegeeks.com\/wp-content\/uploads\/2019\/05\/9.jpeg\")
6.1. Configuring Spring Application<\/h3>\n
@Bean<\/code> annotation in the configuration file<\/p>\npackage springcoreapp;\n\n\/**\n *\n * @author abhishekkothari\n *\/\npublic class HelloJava {\n private String tutorName;\n\n public String getTutorName() {\n return tutorName;\n }\n\n public void setTutorName(String tutorName) {\n this.tutorName = tutorName;\n }\n\n}\n\n<\/pre>\npackage springcoreapp;\n\nimport org.springframework.context.annotation.Bean;\nimport org.springframework.context.annotation.Configuration;\n\n\/**\n *\n * @author abhishekkothari\n *\/\n@Configuration\npublic class HelloSpringConfig {\n @Bean\n public HelloJava helloJava(){\n return new HelloJava();\n }\n}\n<\/pre>\n@Configuration<\/code> signifies that the class needs to be treated as a Spring configuration class. The @Bean<\/code> annotation signifies that the function provides a bean. This configuration is quite manual in that we need to define the functions for each bean. In the present release of Spring, it also allows you to mark the beans as autowired to get eliminate the need for these functions. Now that we have one bean and the configuration file in place, let us run the project and see the bean in action<\/p>\npackage springcoreapp;\n\nimport org.springframework.context.annotation.AnnotationConfigApplicationContext;\n\n\/**\n *\n * @author abhishekkothari\n *\/\npublic class SpringCoreApp {\n\n \/**\n * @param args the command line arguments\n *\/\n public static void main(String[] args) {\n AnnotationConfigApplicationContext ctx = new AnnotationConfigApplicationContext(HelloSpringConfig.class);\n\n HelloJava hellojava = ctx.getBean(HelloJava.class);\n hellojava.setTutorName(\"Abhishek Kothari!\");\n hellojava.getTutorName();\n }\n}\n<\/pre>\nmain<\/code> function code line by line. The first line in the function loads the application configuration using the annotation based configuration feature. The class specifies a single configuration file that we had created and uses that to pass the configuration to the Spring Framework. There might be a need to have multiple configuration files which we will cover later in the tutorial. The next line of code tries to get the bean using the annotation context object that was created before. This method tries to lookup the function with the @Bean<\/code> annotation returning the class object that is passed as the argument in the function. This means that if we have passed HelloJava.class<\/code>, it will look up for a function with return type HelloJava<\/code>. You must have noticed this function in the configuration file that we created above. The further code in the function is simple object operations. To get an actual output in the code, let us add a print statement as well. The code will look like the one shown below.[ulp id=’7POIYxRf1FUtPpmL’]<\/p>\npackage springcoreapp;\n\nimport org.springframework.context.annotation.AnnotationConfigApplicationContext;\n\n\/**\n *\n * @author abhishekkothari\n *\/\npublic class SpringCoreApp {\n\n \/**\n * @param args the command line arguments\n *\/\n public static void main(String[] args) {\n AnnotationConfigApplicationContext ctx = new AnnotationConfigApplicationContext(HelloSpringConfig.class);\n\n HelloJava hellojava = ctx.getBean(HelloJava.class);\n hellojava.setTutorName(\"Abhishek Kothari!\");\n System.out.println(hellojava.getTutorName());\n }\n}\n<\/pre>\n6.2 Running the Spring Core App<\/h3>\n
run:\nException in thread \"main\" java.lang.NoClassDefFoundError: org\/springframework\/beans\/factory\/support\/BeanDefinitionRegistry\n\tat java.lang.ClassLoader.defineClass1(Native Method)\n\tat java.lang.ClassLoader.defineClass(ClassLoader.java:763)\n\tat java.security.SecureClassLoader.defineClass(SecureClassLoader.java:142)\n\tat java.net.URLClassLoader.defineClass(URLClassLoader.java:467)\n\tat java.net.URLClassLoader.access$100(URLClassLoader.java:73)\n\tat java.net.URLClassLoader$1.run(URLClassLoader.java:368)\n\tat java.net.URLClassLoader$1.run(URLClassLoader.java:362)\n\tat java.security.AccessController.doPrivileged(Native Method)\n\tat java.net.URLClassLoader.findClass(URLClassLoader.java:361)\n\tat java.lang.ClassLoader.loadClass(ClassLoader.java:424)\n\tat sun.misc.Launcher$AppClassLoader.loadClass(Launcher.java:335)\n\tat java.lang.ClassLoader.loadClass(ClassLoader.java:357)\n\tat java.lang.ClassLoader.defineClass1(Native Method)\n\tat java.lang.ClassLoader.defineClass(ClassLoader.java:763)\n\tat java.security.SecureClassLoader.defineClass(SecureClassLoader.java:142)\n\tat java.net.URLClassLoader.defineClass(URLClassLoader.java:467)\n\tat java.net.URLClassLoader.access$100(URLClassLoader.java:73)\n\tat java.net.URLClassLoader$1.run(URLClassLoader.java:368)\n\tat java.net.URLClassLoader$1.run(URLClassLoader.java:362)\n\tat java.security.AccessController.doPrivileged(Native Method)\n\tat java.net.URLClassLoader.findClass(URLClassLoader.java:361)\n\tat java.lang.ClassLoader.loadClass(ClassLoader.java:424)\n\tat sun.misc.Launcher$AppClassLoader.loadClass(Launcher.java:335)\n\tat java.lang.ClassLoader.loadClass(ClassLoader.java:357)\n\tat springcoreapp.SpringCoreApp.main(SpringCoreApp.java:20)\nCaused by: java.lang.ClassNotFoundException: org.springframework.beans.factory.support.BeanDefinitionRegistry\n\tat java.net.URLClassLoader.findClass(URLClassLoader.java:381)\n\tat java.lang.ClassLoader.loadClass(ClassLoader.java:424)\n\tat sun.misc.Launcher$AppClassLoader.loadClass(Launcher.java:335)\n\tat java.lang.ClassLoader.loadClass(ClassLoader.java:357)\n\t... 25 more\n\/Users\/abhishekkothari\/Library\/Caches\/NetBeans\/8.2\/executor-snippets\/run.xml:53: Java returned: 1\nBUILD FAILED (total time: 1 second)\n\n<\/pre>\n
run:\nAbhishek Kothari!\nBUILD SUCCESSFUL (total time: 1 second)\n<\/pre>\n
7. Using multiple configuration files<\/h2>\n
package springcoreapp;\n\n\/**\n *\n * @author abhishekkothari\n *\/\npublic class HelloSecondTime {\n private String studentName;\n\n public String getStudentName() {\n return studentName;\n }\n\n public void setStudentName(String studentName) {\n this.studentName = studentName;\n }\n\n}\n\n<\/pre>\npackage springcoreapp;\n\nimport org.springframework.context.annotation.Bean;\nimport org.springframework.context.annotation.Configuration;\n\n\/**\n *\n * @author abhishekkothari\n *\/\n@Configuration\npublic class HelloSecondConfig {\n @Bean\n public HelloSecondTime helloSecondTime(){\n return new HelloSecondTime();\n }\n}\n<\/pre>\npackage springcoreapp;\n\nimport org.springframework.context.annotation.AnnotationConfigApplicationContext;\n\n\/**\n *\n * @author abhishekkothari\n *\/\npublic class SpringCoreApp {\n\n \/**\n * @param args the command line arguments\n *\/\n public static void main(String[] args) {\n AnnotationConfigApplicationContext ctx = new AnnotationConfigApplicationContext();\n ctx.register(HelloSpringConfig.class);\n ctx.register(HelloSecondConfig.class);\n ctx.refresh();\n HelloJava hellojava = ctx.getBean(HelloJava.class);\n hellojava.setTutorName(\"Abhishek Kothari!\");\n System.out.println(hellojava.getTutorName());\n \n HelloSecondTime helloSecondTime = ctx.getBean(HelloSecondTime.class);\n helloSecondTime.setStudentName(\"You!\");\n System.out.println(helloSecondTime.getStudentName());\n }\n \n}\n\n<\/pre>\n
Abhishek Kothari!
You!
BUILD SUCCESSFUL (total time: 2 seconds)<\/p>\n8. Spring Netbeans – Conclusion<\/h2>\n
9. Download<\/h2>\n