The structure of the code for launching a web project
In the project, for example, I made the connection of the client and server parts via Rest and WebSocket. Who likes what more. There are a great many descriptions of the Spring Framework and Rect technologies themselves on the Internet. This article is for those who have something that doesn’t work out, or something is lazy. This is a customized ready-made working solution containing everything you need to grow into a full-fledged large project.
You can also take this project as a starting point in learning Java EE or React applications.controller/RestController.java
The client part code is located in the src/main/java folder.
The way everything is located there is completely subordinated to the Spring Framework structure. For those who are familiar with it, they will not find anything interesting there, and for those who are just starting, again, I will just briefly go through the files.
Main.java is the main file. Contains the main method, which launches the entire application.
configuration/WebSocketConfig.java — for entry points when working via WebSocket
Controllers are classes responsible for the interaction of the server and client parts.
controller/IndexController.the java controller is responsible for displaying our client part. Redirecting the user to the url application/** (This is the contextual path to our application)
controller/RestController.java — as the name suggests, this controller is responsible for data exchange between the client and server parts over Rest. Abstract @RequestMapping(value = “/api/rest”, method = RequestMethod.GET) says that upon request at /api/rest, the server will give us a list of users.
I used the PUT method to add users and DELETE, respectively, to delete a user by ID.
controller/WebSocketController.java — defines the path for data exchange via WebSocket. The getAndSendMessage method receives a message from the client and sends it back.
Services are usually responsible for the logic of our application.
service/ORMUserService.java — in my case, is responsible for creating a list of users, as well as adding and deleting users to the database using the parameters received from the client part as data. To delete a user, this is the user ID, and to create it, this is the user’s name, role, and password.
Domain classes are classes that most often contain only data that is projected onto tables in the data bus. From the logic that can be contained in these classes, it is checking the data for correctness or some actions that must be performed immediately before writing data to the database or after reading from it. For example, you can convert from kilograms to grams.
domain/User.java class that will correspond to the Table Table(name = “USER”) in the database.
Data for the column @Column(name = “ID”) will be generated automatically.
domain/Message.java — in my case does not use database mappings. the data in it will be stored while the application is running. It serves me for generating messages sent via WebSocket.
That’s all I have with the server part.
I will not focus on the client side, since React itself is still a fairly young technology. And it has not yet finally formed the best practices that should be used in each specific project. I will only note that I have created the most classical structure as convenient as possible in my opinion for studying.
What has been done at the front:
The main layout of the application and several tabs are implemented.
Implemented translation for the entire application.
Implemented the state of the application on Redux.
Implemented the display of the table of users received from the server via Rest
Implemented the removal of users by id
Implemented the addition of users
Implemented sending and receiving messages via WebSocket
I think this is more than enough to start with.
Leave all your questions and suggestions in the comments or email me. I will be glad to help.
Detailed installation and startup information
OS “Wondows 10”
Installing Java 1.8 detailed instructions
Before starting the installation, press the Win+ R keyboard shortcut and enter cmd
, enter java -version and see
This means that java is not installed on this computer.
If the computer has output the java version and this version is not lower than 1.8, then proceed to the Gradle installation point.
Download Java from the link
You need to click the Accept License Agreement checkbox.
The Windows x64 version we need
Click Next all the time and Ok at the end of close.
After installation, we call the Win+R command line again and enter cmd, enter java -version and see the version of Java we have already installed
Open the properties of your computer
Additional parameters — environment variables
Make sure that the system variables have JAVA_HOME with the value C:\Program Files\Java\jdk1.8.0_181\
And there is a string in the Path variable C:\Program Files\Java\jdk1.8.0_181\bin
Let’s move on to the next point
Gradle installation detailed instructions
Open the console again and enter gradle -version
Since we have not installed it yet, we will see by this:
Download the archive from the link
We unpack for example into such a folder C:\gradle-4.10.1
Next, by analogy with java, we open the section with system variables and independently add the GRADLE_HOME variable with the value C:\gradle-4.10.1\bin
And we also add to the path variable C:\gradle-4.10.1\bin you can even next to the line C:\Program Files\Java\jdk1.8.0_181\bin, but it’s not necessary.
Be sure to restart the Win+R cmd console and enter gradle -version
Everything is now and gradle is installed!
Node JS detailed instructions
Download Node JS from the link
Installing Node js
Restart the command line and enter npm -version and we will definitely see the installed version
Excellent all the preparatory work is done
Download the project as an archive
It weighs only 135 Kb
And unpack in C:\react-start-master\
Run the command line and go to C:\react-start-master\
For those who do not remember to climb up the folder tree in the command line, you need to enter cd..
So we go to the root of the C drive:>
Then we enter cd react-start-master and get the path C:\react-start-master>
enter npm i
Currently, JS dependencies are being downloaded for our project
Warnings are allowed (WARN — warning)
The folder C will appear in the software project:\react-start-master\node_modules all dependencies will be in it.
Immediately after that, we enter gradle build in the console
All dependencies for Java, including Spring, will be downloaded.
The C folder will appear in the project:\react-start-master\build
everything will be assembled and we will see a message about a successful assembly
And immediately after that, you can run the gradle bootRun command
The project will start launching
At the end of the launch, the console will have something like the following
All the project is running!
Don’t close the console, just collapse it.
Open a browser and type localhost:8090/application/ or follow this link
You will see the project running