You are specifying a user in your .service file, hence you should not need to do any of the su magic in your script.

Replace this:

su -s /bin/sh $user -c "cd /app/myworkingdir ; java -jar myjar.jar >> /var/log/systemout.log 2>> /var/log/systemerr.log"

with this:

cd /app/myworkingdir
java -jar myjar.jar >> /var/log/systemout.log 2>> /var/log/systemerr.log"

Besides, I see two further issues in your script:

• You are grepping the process table to find the PID for your service. This may fail if there is another running process with a command line that contains the same characters (the system may end up picking the wrong process to terminate). echo pid_file right after launching java is a safer way of accomplishing this.

• The service type is simple, yet your script forks it as a separate process and then returns. This will confuse systemd, and your service will fail to start.

Both of these might be easy to solve. I assume you need the PID only to stop the service, and doing so is as simple as sending it a SIGINT. In that case you can take advantage of the fact that, in the absence of ExecStop, systemd will simply send a SIGINT to the service process to stop it.

• Drop the ampersand after the java call, and prefix it with exec instead. That way, the java process becomes will be treated as the daemon process by systemd.

• Drop the PID magic after the java call altogether.

• In the .service file, remove the ExecStop entry.

• Instead, also under [Service], add SuccessExitStatus=143. (When terminated with a signal, the JVM will exit with a nonzero exit status, namely 128 plus the signal. By default, systemd treats an exit status of 143 as a failure; this entry will tell systemd that 143 stands for graceful exit.)

You could take this one step further and drop the script altogether:

• Specify the java command line as ExecStart
• Pass the full path to the java binary (as reported by which java)
• Drop the redirections: by default, systemd will redirect stdout and stderr to the journal. (This can be configured in the .service file as well.)

You may not need the shell script. You can start the process from the myService.service file provided you use the full path to both the java binary and the jar file. It should look something like

ExecStart=/usr/bin/java -jar /home/pruss/dev/ServerDeploy5-4.1/Server/resources/MyServer.jar

Works on CentOS 7.2.

Using systemd directives in place of shell results in a more consistent environment. This includes not relying on $PATH or the working directory by providing full paths where they are known.

Neither & for job control, nor managing SIGHUP is needed. systemd service units are already backgrounded.

Assuming the program doesn't fork, in other words the java exec keeps running, that's Type=simple

[Unit]
Description=something

[Service]
ExecStart=/usr/bin/java -jar /var/www/test.com/something.jar
StandardOutput=file:/var/log/something.out.txt
StandardError=file:/var/log/something.err.txt
Type=simple
WorkingDirectory=/var/www/test.com

[Install]
WantedBy=multi-user.target

Here's some minor modifications:

1. Since it listens on a network socket, make it a dependency of network.target.
2. nohup is not needed since systemd will daemonize the executable for you.
3. I think a separate shell script would be an overkill, so just merge it into the service file.
4. Redirection (< /dev/null and so forth) isn't needed since systemd sets up an appropriate standard I/O context. Indeed, if you take the redirection out systemd will log anything sent to standard output by the Java program in its journal, with no special logging mechanism required.
5. Running asynchonously from the invoking shell (&) isn't needed or appropriate.
6. There's a specific behaviour pattern required by Type=forking, and if it isn't followed by the dæmon things go wrong. So try for Type=simple (or Type=notify).

So the service file looks like this:

[Unit]
Description=Some job
After=network.target

[Service]
WorkingDirectory=/home/user/tmp/testout
SyslogIdentifier=SocketTest
ExecStart=/bin/sh -c "exec java -jar /home/user/programming/tests/java/core/SocketTest/SocketTest.jar"
User=dlt
Type=simple

[Install]
WantedBy=multi-user.target

Notes:

1. You cannot just use java as the name of the program to run. systemd doesn't search PATH for executables, and the name of the executable given to ExecStart must be absolute. So if you want path searching you have to invoke via a shell or /usr/bin/env. We choose /bin/sh here.
2. Because this is Type=simple the shell must exec Java, not run it as a child process. systemd controls the service through the main process, and that needs to be Java, not a parent shell process.
3. Because this isn't invoking the Java executable directly, systemd will put the name sh in its journal as the service name. See How to avoid /usr/bin/env being marked in systemd logs as the executable for more on this.

As far as I know, there is no special caveat of running Java application with Systemd.

You could use the Linux kernel support for miscellaneous binary formats (binfmt_misc). This allows you to register an interpreter (e.g. Java) to execute a file based on the first few bytes in the file (e.g. a jar file). See https://www.kernel.org/doc/Documentation/admin-guide/binfmt-misc.rst for more information.

The JVM argument java.net.preferIPv4Stack should be prefixed with -D instead you have D

Also, as others pointed out in comments check your java path it might be /usr/bin/java.

So, change the command to /usr/bin/java -Xms128m -Xmx256m -jar -Djava.net.preferIPv4Stack=true EdOwl-Springboot.jar