End of life sometime after 2019. Life will be prolonged by major and minor updates to ALL frameworks and libraries
(by progressively updating the app whenever a new version comes out for libraries we rely on, we can prevent spending days/weeks/months on a rewrite in the future)

If you are making a company project :

• You NEED nexus access, contact anthony.arents@mentoringsystems.be

All new projects have specific requirements in the buildprocess :

• Netbeans project
• Maven (download latest version for significant speed/memory improvements)
• Spring (latest)
• Spring Security (latest)
• Hibernate (latest 5.4)
• Javamelody (latest, developer tool, used for statistics)
• ExtJS (frontend latest) or Bootstrap+JQuery
• Java 8 or 9, it's compatible with both
• Mysql 5.7 (beware the date madness : timestamp(6) & datetime(6))
• Tomcat 8.5 (DOWNLOAD NEWEST FROM THEIR WEBSITE! required for java config, earlier versions supplied with netbeans are bad)

Code examples were taken from BoardPortal, PayByMail, Merke, SuiteOfTheFuture, Mobi
This documentation is still a work in progress.

• Netbeans 8.2
• Mysql 5.7 : you can use the installer, copy the password when presented ! Mac users : you can find the start & stop in System Preferences : use sequel pro to connect)

Things that SHOULD BE dropped and no longer used :

• SimpleDateFormat (use FastDateFormat)
• Base64 encoding (unless it's needed for webservices, then we'll be switching to java8 base64 utils)
• iText (would be better to switch to apache pdfbox… unless a license is available)
• javacsv (can be done with jackson library now)
• Apache httpclient (can probably be easily replaced by something easier to use)
• commons fileupload (no longer needed)
• Dozer (wish we never used this slow thing, got beaten by Mario for a reason)
• Joda time (obsolete with java8)

mvn site → generated version reports

https://spring.io/blog

Be aware, sometimes, a method is not safe for use in webapplications, prevent setting things static at all time
unless they are threadsafe (like Log4J).
For example : SimpleDateFormat, when made static is thread unsafe & may start confusing dates passed to it → use new JAVA8 date.

Please use the maven site ! It will calculate PMD + Findbugs for you.
Just rightclick the project : “Run Maven” → “Goals …” → type “site” & save as “site”.
You'll be able to run it again with “Run Maven” → “site”.

In the generated output, there's a link : “View generated site”. You can use this link when Maven is finished.

You should solve all Findbugs & PMD errors. (except maybe jaxws & hibernate packages)

be.mentoringsystems.applicationname.config

Contains Configuration classes used to configure the application

be.mentoringsystems.applicationname.config.initializer

Contains 2 classes: one to create the servlet and one to initialize spring security

be.mentoringsystems.applicationname.dao

Contains DAO interfaces, naming ObjectnameDAO

be.mentoringsystems.applicationname.dao.hibernate

Contains DAO implementations, naming ObjectnameDAOImpl, extends HibernateDaoSupport, implements ObjectnameDAO

be.mentoringsystems.applicationname.dao.importer

Contains importer interfaces

be.mentoringsystems.applicationname.dao.importer.excel

Contains excel importer interfaces

be.mentoringsystems.applicationname.dao.importer.csv

Contains csv importer interfaces

be.mentoringsystems.applicationname.model

Contains helper models which may be used throughout the application (for example QueryParams)

be.mentoringsystems.applicationname.model.db

Contains models which will be stored in the database, naming Ojectname

be.mentoringsystems.applicationname.model.dto

Contains models which will be intermediaries for the Controller interfaces (forms sent to server end up in a dto which are then translated to models in the service api)

be.mentoringsystems.applicationname.presentation

Contains viewcontrollers, Restcontrollers have their own package to make it easier to find them.

be.mentoringsystems.applicationname.presentation.conversion

Contains convertors for deserializing (spring).

be.mentoringsystems.applicationname.presentation.excel

Contains excel views using apache poi

be.mentoringsystems.applicationname.presentation.rest

Contains controllers which will be accessed via Rest

be.mentoringsystems.applicationname.presentation.serializer

Contains Jackson serializers

be.mentoringsystems.applicationname.service

Contains Service interfaces, naming ObjectnameService

be.mentoringsystems.applicationname.service.impl

Contains Service implementations, naming ObjectnameServiceImpl, implements ObjectnameService, uses ObjectnameDAO & Transactional annotations

be.mentoringsystems.applicationname.tasks

Contains ScheduledTasks class which has several automated tasks

de.jcpis.applicationname

see above for details.

Start with creating mocks & database model

Create a new project : New Project → Maven → Web Application

Change the POM (configuration files → pom.xml) to this :

pom.xml

<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>
 
    <groupId>be.mentoringsystems</groupId>
    <artifactId>Merke</artifactId>
    <version>1.0-SNAPSHOT</version>
    <packaging>war</packaging>
 
    <name>Merke</name>
 
    <properties>
        <!-- tomcat7 -->
        <!-- javax.servletapi>3.1.0</javax.servletapi -->
        <!-- javax.servletjspapi>2.3.1</javax.servletjspapi -->
        <!-- javax.elapi>3.0.0</javax.elapi -->
        <!-- tomcat8 -->
        <javax.servletapi>4.0.1</javax.servletapi>
        <javax.servletjspapi>2.3.3</javax.servletjspapi>
        <javax.elapi>3.0.0</javax.elapi>
 
        <spring>5.2.0.RELEASE</spring>
        <springsecurity>5.2.0.RELEASE</springsecurity>
        <mysql>8.0.17</mysql>
        <dbcp>2.7.0</dbcp>
        <hibernate>5.4.6.Final</hibernate>
        <hibernate.validator>6.0.17.Final</hibernate.validator>
        <jackson>2.10.0</jackson>
        <apache.taglibs>1.2.5</apache.taglibs>
        <log4j>2.12.1</log4j>
        <commons.lang>3.9</commons.lang>
        <commons.text>1.8</commons.text>
        <commons.io>2.6</commons.io>
        <commons.beanutils>1.9.4</commons.beanutils>
        <javax.mail>1.6.2</javax.mail>
        <apache.poi>4.1.0</apache.poi>
        <javamelody>1.79.0</javamelody>
        <findbugs.helper>3.0.2</findbugs.helper>
        <jsoup>1.12.1</jsoup>
        <im4java>1.4.0</im4java>
        <auth0.jwt>3.8.3</auth0.jwt>
        <metadataextractor>2.12.0</metadataextractor>
        <stax2api>4.2</stax2api>
 
        <maven.compiler.source>1.8</maven.compiler.source>
        <maven.compiler.target>1.8</maven.compiler.target>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
 
        <report.plugin.maven.inforeports>3.0.0</report.plugin.maven.inforeports>
        <report.plugin.maven.jxr>3.0.0</report.plugin.maven.jxr>
        <report.plugin.maven.javadoc>3.1.1</report.plugin.maven.javadoc>
        <report.plugin.maven.checkstyle>3.1.0</report.plugin.maven.checkstyle>
        <report.plugin.maven.checkstyle.checkstyleversion>8.25</report.plugin.maven.checkstyle.checkstyleversion>
        <checkstyle.config.location>checkstyle.xml</checkstyle.config.location>
        <report.plugin.maven.pmd>3.12.0</report.plugin.maven.pmd>
        <report.plugin.maven.pmd.pmdversion>6.18.0</report.plugin.maven.pmd.pmdversion>
        <report.plugin.maven.surefire>3.0.0-M3</report.plugin.maven.surefire>
        <report.plugin.codehaus.findbugs>3.0.5</report.plugin.codehaus.findbugs>
        <report.plugin.codehaus.taglist>2.4</report.plugin.codehaus.taglist>
        <report.plugin.codehaus.versions>2.7</report.plugin.codehaus.versions>
 
        <build.plugin.maven.site>3.8.2</build.plugin.maven.site>
        <build.plugin.maven.compiler>3.8.1</build.plugin.maven.compiler>
        <build.plugin.maven.deploy>3.0.0-M1</build.plugin.maven.deploy>
        <build.plugin.maven.clean>3.1.0</build.plugin.maven.clean>
        <build.plugin.maven.install>3.0.0-M1</build.plugin.maven.install>
        <build.plugin.maven.dependency>3.1.1</build.plugin.maven.dependency>
        <build.plugin.maven.war>3.2.3</build.plugin.maven.war>
        <build.plugin.maven.resources>3.1.0</build.plugin.maven.resources>
        <build.plugin.maven.surefire>3.0.0-M3</build.plugin.maven.surefire>
        <build.plugin.maven.antrun>1.8</build.plugin.maven.antrun>
        <build.plugin.maven.assembly>3.1.1</build.plugin.maven.assembly>
        <build.plugin.maven.release>2.5.3</build.plugin.maven.release>
    </properties>
 
    <dependencies>
        <dependency>
            <groupId>javax.servlet</groupId>
            <artifactId>javax.servlet-api</artifactId>
            <version>${javax.servletapi}</version>
            <scope>provided</scope>
        </dependency>
        <dependency>
            <groupId>javax.servlet.jsp</groupId>
            <artifactId>javax.servlet.jsp-api</artifactId>
            <version>${javax.servletjspapi}</version>
            <scope>provided</scope>
        </dependency>
        <dependency>
            <groupId>javax.el</groupId>
            <artifactId>javax.el-api</artifactId>
            <version>${javax.elapi}</version>
            <scope>provided</scope>
        </dependency>
        <dependency>
            <groupId>org.apache.taglibs</groupId>
            <artifactId>taglibs-standard-spec</artifactId>
            <version>${apache.taglibs}</version>
        </dependency>
        <dependency>
            <groupId>org.apache.taglibs</groupId>
            <artifactId>taglibs-standard-impl</artifactId>
            <version>${apache.taglibs}</version>
        </dependency>
        <dependency>
            <groupId>org.im4java</groupId>
            <artifactId>im4java</artifactId>
            <version>${im4java}</version>
        </dependency>
        <!-- Spring dependencies -->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-core</artifactId>
            <version>${spring}</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-web</artifactId>
            <version>${spring}</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-webmvc</artifactId>
            <version>${spring}</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-orm</artifactId>
            <version>${spring}</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context-support</artifactId>
            <version>${spring}</version>
        </dependency>
        <!-- Spring Security -->
        <dependency>
            <groupId>org.springframework.security</groupId>
            <artifactId>spring-security-web</artifactId>
            <version>${springsecurity}</version>
        </dependency>
        <dependency>
            <groupId>org.springframework.security</groupId>
            <artifactId>spring-security-config</artifactId>
            <version>${springsecurity}</version>
        </dependency>
        <dependency>
            <groupId>org.springframework.security</groupId>
            <artifactId>spring-security-taglibs</artifactId>
            <version>${springsecurity}</version>
        </dependency>
        <!-- DBCP (database) -->
        <dependency>
            <groupId>org.apache.commons</groupId>
            <artifactId>commons-dbcp2</artifactId>
            <version>${dbcp}</version>
        </dependency>
        <dependency>
            <groupId>org.apache.commons</groupId>
            <artifactId>commons-lang3</artifactId>
            <version>${commons.lang}</version>
        </dependency>
        <dependency>
            <groupId>org.apache.commons</groupId>
            <artifactId>commons-text</artifactId>
            <version>${commons.text}</version>
        </dependency>
        <!-- Mysql -->
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>${mysql}</version>
        </dependency>
        <!-- Hibernate -->
        <dependency>
            <groupId>org.hibernate</groupId>
            <artifactId>hibernate-core</artifactId>
            <version>${hibernate}</version>
            <exclusions>
                <exclusion>
                    <groupId>com.fasterxml</groupId>
                    <artifactId>classmate</artifactId>
                </exclusion>
            </exclusions>
        </dependency>
        <dependency>
            <groupId>org.hibernate</groupId>
            <artifactId>hibernate-validator</artifactId>
            <version>${hibernate.validator}</version>
        </dependency>
        <dependency>
            <groupId>org.jsoup</groupId>
            <artifactId>jsoup</artifactId>
            <version>${jsoup}</version>
        </dependency>
        <dependency>
            <groupId>com.fasterxml.jackson.core</groupId>
            <artifactId>jackson-core</artifactId>
            <version>${jackson}</version>
        </dependency>
        <dependency>
            <groupId>com.fasterxml.jackson.core</groupId>
            <artifactId>jackson-databind</artifactId>
            <version>${jackson}</version>
            <exclusions>
                <exclusion>
                    <groupId>com.fasterxml.jackson.core</groupId>
                    <artifactId>jackson-annotations</artifactId>
                </exclusion>
            </exclusions>
        </dependency>
        <dependency>
            <groupId>com.fasterxml.jackson.core</groupId>
            <artifactId>jackson-annotations</artifactId>
            <version>${jackson}</version>
        </dependency>
        <dependency>
            <groupId>com.fasterxml.jackson.dataformat</groupId>
            <artifactId>jackson-dataformat-xml</artifactId>
            <version>${jackson}</version>
            <exclusions>
                <exclusion>
                    <groupId>com.fasterxml.jackson.core</groupId>
                    <artifactId>jackson-annotations</artifactId>
                </exclusion>
            </exclusions>
        </dependency>
        <dependency>
            <groupId>com.fasterxml.jackson.dataformat</groupId>
            <artifactId>jackson-dataformat-csv</artifactId>
            <version>${jackson}</version>
            <exclusions>
                <exclusion>
                    <groupId>com.fasterxml.jackson.core</groupId>
                    <artifactId>jackson-annotations</artifactId>
                </exclusion>
            </exclusions>
        </dependency>
        <dependency>
            <groupId>com.fasterxml.jackson.datatype</groupId>
            <artifactId>jackson-datatype-jsr310</artifactId>
            <version>${jackson}</version>
            <exclusions>
                <exclusion>
                    <groupId>com.fasterxml.jackson.core</groupId>
                    <artifactId>jackson-annotations</artifactId>
                </exclusion>
            </exclusions>
        </dependency>
        <dependency>
            <groupId>com.fasterxml.jackson.datatype</groupId>
            <artifactId>jackson-datatype-hibernate5</artifactId>
            <version>${jackson}</version>
            <exclusions>
                <exclusion>
                    <groupId>com.fasterxml.jackson.core</groupId>
                    <artifactId>jackson-annotations</artifactId>
                </exclusion>
            </exclusions>
        </dependency>
        <dependency>
            <groupId>org.apache.logging.log4j</groupId>
            <artifactId>log4j-core</artifactId>
            <version>${log4j}</version>
        </dependency>
        <dependency>
            <groupId>org.apache.logging.log4j</groupId>
            <artifactId>log4j-api</artifactId>
            <version>${log4j}</version>
        </dependency>
        <dependency>
            <groupId>org.apache.logging.log4j</groupId>
            <artifactId>log4j-web</artifactId>
            <version>${log4j}</version>
        </dependency>
        <dependency>
            <groupId>org.apache.logging.log4j</groupId>
            <artifactId>log4j-slf4j-impl</artifactId>
            <version>${log4j}</version>
        </dependency>
        <dependency>
            <groupId>commons-io</groupId>
            <artifactId>commons-io</artifactId>
            <version>${commons.io}</version>
        </dependency>
        <dependency>
            <groupId>commons-beanutils</groupId>
            <artifactId>commons-beanutils</artifactId>
            <version>${commons.beanutils}</version>
        </dependency>
        <dependency>
            <groupId>com.sun.mail</groupId>
            <artifactId>javax.mail</artifactId>
            <version>${javax.mail}</version>
        </dependency>
        <dependency>
            <groupId>org.apache.poi</groupId>
            <artifactId>poi</artifactId>
            <version>${apache.poi}</version>
            <exclusions>
                <exclusion>
                    <groupId>commons-codec</groupId>
                    <artifactId>commons-codec</artifactId>
                </exclusion>
            </exclusions>
        </dependency>
        <dependency>
            <groupId>org.apache.poi</groupId>
            <artifactId>poi-ooxml</artifactId>
            <version>${apache.poi}</version>
        </dependency>
        <dependency>
            <groupId>net.bull.javamelody</groupId>
            <artifactId>javamelody-core</artifactId>
            <version>${javamelody}</version>
        </dependency>
        <dependency>
            <groupId>com.google.code.findbugs</groupId>
            <artifactId>jsr305</artifactId>
            <version>${findbugs.helper}</version>
        </dependency>
        <dependency>
            <groupId>com.auth0</groupId>
            <artifactId>java-jwt</artifactId>
            <version>${auth0.jwt}</version>
        </dependency>
        <dependency>
            <groupId>com.drewnoakes</groupId>
            <artifactId>metadata-extractor</artifactId>
            <version>${metadataextractor}</version>
        </dependency>
    </dependencies>
 
    <reporting>
        <plugins>
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-project-info-reports-plugin</artifactId>
                <version>${report.plugin.maven.inforeports}</version>
            </plugin>
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-jxr-plugin</artifactId>
                <version>${report.plugin.maven.jxr}</version>
            </plugin>
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-surefire-report-plugin</artifactId>
                <version>${report.plugin.maven.surefire}</version>
            </plugin>
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-javadoc-plugin</artifactId>
                <version>${report.plugin.maven.javadoc}</version>
                <configuration>
                    <doclint>none</doclint>
                </configuration>
            </plugin>
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-checkstyle-plugin</artifactId>
                <version>${report.plugin.maven.checkstyle}</version>
                <reportSets>
                    <reportSet>
                        <reports>
                            <report>checkstyle</report>
                        </reports>
                    </reportSet>
                </reportSets>
            </plugin>
            <plugin>
                <groupId>org.codehaus.mojo</groupId>
                <artifactId>taglist-maven-plugin</artifactId>
                <version>${report.plugin.codehaus.taglist}</version>
            </plugin>
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-pmd-plugin</artifactId>
                <version>${report.plugin.maven.pmd}</version>
                <configuration>
                    <skipEmptyReport>false</skipEmptyReport>
                    <analysisCache>true</analysisCache>
                </configuration>
            </plugin>
            <plugin>
                <groupId>org.codehaus.mojo</groupId>
                <artifactId>findbugs-maven-plugin</artifactId>
                <version>${report.plugin.codehaus.findbugs}</version>
            </plugin>
            <plugin>
                <groupId>org.codehaus.mojo</groupId>
                <artifactId>versions-maven-plugin</artifactId>
                <version>${report.plugin.codehaus.versions}</version>
                <reportSets>
                    <reportSet>
                        <reports>
                            <report>dependency-updates-report</report>
                            <report>plugin-updates-report</report>
                            <report>property-updates-report</report>
                        </reports>
                    </reportSet>
                </reportSets>
            </plugin>
        </plugins>
    </reporting>
 
    <build>
        <pluginManagement>
            <plugins>
                <plugin>
                    <groupId>org.apache.maven.plugins</groupId>
                    <artifactId>maven-pmd-plugin</artifactId>
                    <version>${report.plugin.maven.pmd}</version>
                    <dependencies>
                        <dependency>
                            <groupId>net.sourceforge.pmd</groupId>
                            <artifactId>pmd-core</artifactId>
                            <version>${report.plugin.maven.pmd.pmdversion}</version>
                        </dependency>
                        <dependency>
                            <groupId>net.sourceforge.pmd</groupId>
                            <artifactId>pmd-java</artifactId>
                            <version>${report.plugin.maven.pmd.pmdversion}</version>
                        </dependency>
                        <dependency>
                            <groupId>net.sourceforge.pmd</groupId>
                            <artifactId>pmd-javascript</artifactId>
                            <version>${report.plugin.maven.pmd.pmdversion}</version>
                        </dependency>
                        <dependency>
                            <groupId>net.sourceforge.pmd</groupId>
                            <artifactId>pmd-jsp</artifactId>
                            <version>${report.plugin.maven.pmd.pmdversion}</version>
                        </dependency>
                    </dependencies>
                </plugin>
                <plugin>
                    <groupId>org.apache.maven.plugins</groupId>
                    <artifactId>maven-checkstyle-plugin</artifactId>
                    <version>${report.plugin.maven.checkstyle}</version>
                    <dependencies>
                        <dependency>
                            <groupId>com.puppycrawl.tools</groupId>
                            <artifactId>checkstyle</artifactId>
                            <version>${report.plugin.maven.checkstyle.checkstyleversion}</version>
                        </dependency>
                    </dependencies>
                </plugin>
                <plugin>
                    <groupId>org.apache.maven.plugins</groupId>
                    <artifactId>maven-antrun-plugin</artifactId>
                    <version>${build.plugin.maven.antrun}</version>
                </plugin>
                <plugin>
                    <groupId>org.apache.maven.plugins</groupId>
                    <artifactId>maven-assembly-plugin</artifactId>
                    <version>${build.plugin.maven.assembly}</version>
                </plugin>
                <plugin>
                    <groupId>org.apache.maven.plugins</groupId>
                    <artifactId>maven-release-plugin</artifactId>
                    <version>${build.plugin.maven.release}</version>
                </plugin>
                <plugin>
                    <groupId>org.apache.maven.plugins</groupId>
                    <artifactId>maven-dependency-plugin</artifactId>
                    <version>${build.plugin.maven.dependency}</version>
                </plugin>
            </plugins>
        </pluginManagement>
        <plugins>
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-site-plugin</artifactId>
                <version>${build.plugin.maven.site}</version>
            </plugin>
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-compiler-plugin</artifactId>
                <version>${build.plugin.maven.compiler}</version>
                <configuration>
                    <encoding>${project.build.sourceEncoding}</encoding>
                    <source>${maven.compiler.source}</source>
                    <target>${maven.compiler.target}</target>
                </configuration>
            </plugin>
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-deploy-plugin</artifactId>
                <version>${build.plugin.maven.deploy}</version>
            </plugin>
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-clean-plugin</artifactId>
                <version>${build.plugin.maven.clean}</version>
            </plugin>
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-install-plugin</artifactId>
                <version>${build.plugin.maven.install}</version>
            </plugin>
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-war-plugin</artifactId>
                <version>${build.plugin.maven.war}</version>
                <configuration>
                    <useCache>false</useCache>
                    <packagingExcludes>
                        static/Merke/**
                    </packagingExcludes>
                </configuration>
            </plugin>
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-resources-plugin</artifactId>
                <version>${build.plugin.maven.resources}</version>
                <configuration>
                    <encoding>${project.build.sourceEncoding}</encoding>
                </configuration>
            </plugin>
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-surefire-plugin</artifactId>
                <version>${build.plugin.maven.surefire}</version>
                <configuration>
                    <skipTests>${skipTests}</skipTests>
                    <argLine>-XX:-UseSplitVerifier</argLine>
                </configuration>
            </plugin>
        </plugins>
    </build>
 
</project>

This will set most of your dependencies straight,
Be sure to check the graph to solve the dependency conflicts.
The parent pom ensures all projects use UTF-8 encoding for files & sets some maven plugins.

This xml file is based on sun_checks (removed some annoying ones). Place this in the ROOT folder of your webapp (next to pom.xml) as checkstyle.xml

checkstyle.xml

<?xml version="1.0"?>
<!DOCTYPE module PUBLIC
          "-//Puppy Crawl//DTD Check Configuration 1.3//EN"
          "http://checkstyle.sourceforge.net/dtds/configuration_1_3.dtd">
 
<!--
 
  Checkstyle configuration that checks the sun coding conventions from:
 
    - the Java Language Specification at
      http://java.sun.com/docs/books/jls/second_edition/html/index.html
 
    - the Sun Code Conventions at http://java.sun.com/docs/codeconv/
 
    - the Javadoc guidelines at
      http://java.sun.com/j2se/javadoc/writingdoccomments/index.html
 
    - the JDK Api documentation http://java.sun.com/j2se/docs/api/index.html
 
    - some best practices
 
  Checkstyle is very configurable. Be sure to read the documentation at
  http://checkstyle.sf.net (or in your downloaded distribution).
 
  Most Checks are configurable, be sure to consult the documentation.
 
  To completely disable a check, just comment it out or delete it from the file.
 
  Finally, it is worth reading the documentation.
 
-->
 
<module name="Checker">
    <!--
        If you set the basedir property below, then all reported file
        names will be relative to the specified directory. See
        http://checkstyle.sourceforge.net/5.x/config.html#Checker
 
        <property name="basedir" value="${basedir}"/>
    -->
 
    <property name="fileExtensions" value="java, properties, xml"/>
 
    <!-- Checks that a package-info.java file exists for each package.     -->
    <!-- See http://checkstyle.sf.net/config_javadoc.html#JavadocPackage -->
    <!--module name="JavadocPackage"/-->
 
    <!-- Checks whether files end with a new line.                        -->
    <!-- See http://checkstyle.sf.net/config_misc.html#NewlineAtEndOfFile -->
    <module name="NewlineAtEndOfFile"/>
 
    <!-- Checks that property files contain the same keys.         -->
    <!-- See http://checkstyle.sf.net/config_misc.html#Translation -->
    <module name="Translation"/>
 
    <!-- Checks for Size Violations.                    -->
    <!-- See http://checkstyle.sf.net/config_sizes.html -->
    <module name="FileLength"/>
 
    <!-- Checks for whitespace                               -->
    <!-- See http://checkstyle.sf.net/config_whitespace.html -->
    <module name="FileTabCharacter"/>
 
    <!-- Miscellaneous other checks.                   -->
    <!-- See http://checkstyle.sf.net/config_misc.html -->
    <module name="RegexpSingleline">
        <property name="format" value="\s+$"/>
        <property name="minimum" value="0"/>
        <property name="maximum" value="0"/>
        <property name="message" value="Line has trailing spaces."/>
    </module>
 
    <!-- Checks for Size Violations.                    -->
    <!-- See http://checkstyle.sf.net/config_sizes.html -->
    <module name="LineLength">
        <property name="max" value="120"/>
    </module>
 
    <!-- Checks for Headers                                -->
    <!-- See http://checkstyle.sf.net/config_header.html   -->
    <!-- <module name="Header"> -->
    <!--   <property name="headerFile" value="${checkstyle.header.file}"/> -->
    <!--   <property name="fileExtensions" value="java"/> -->
    <!-- </module> -->
 
    <module name="TreeWalker">
 
        <!-- Checks for Javadoc comments.                     -->
        <!-- See http://checkstyle.sf.net/config_javadoc.html -->
        <!--module name="JavadocMethod"/-->
        <!--module name="JavadocType"/-->
        <!--module name="JavadocVariable"/-->
        <!--module name="JavadocStyle"/-->
 
        <!-- Checks for Naming Conventions.                  -->
        <!-- See http://checkstyle.sf.net/config_naming.html -->
        <module name="ConstantName"/>
        <module name="LocalFinalVariableName"/>
        <module name="LocalVariableName"/>
        <module name="MemberName"/>
        <module name="MethodName"/>
        <module name="PackageName"/>
        <module name="ParameterName"/>
        <module name="StaticVariableName"/>
        <module name="TypeName"/>
 
        <!-- Checks for imports                              -->
        <!-- See http://checkstyle.sf.net/config_import.html -->
        <module name="AvoidStarImport"/>
        <module name="IllegalImport"/> <!-- defaults to sun.* packages -->
        <module name="RedundantImport"/>
        <module name="UnusedImports">
            <property name="processJavadoc" value="false"/>
        </module>
        <module name="MethodLength"/>
        <module name="ParameterNumber"/>
 
        <!-- Checks for whitespace                               -->
        <!-- See http://checkstyle.sf.net/config_whitespace.html -->
        <module name="EmptyForIteratorPad"/>
        <module name="GenericWhitespace"/>
        <module name="MethodParamPad"/>
        <module name="NoWhitespaceAfter"/>
        <module name="NoWhitespaceBefore"/>
        <module name="OperatorWrap"/>
        <module name="ParenPad"/>
        <module name="TypecastParenPad"/>
        <module name="WhitespaceAfter"/>
        <module name="WhitespaceAround"/>
 
        <!-- Modifier Checks                                    -->
        <!-- See http://checkstyle.sf.net/config_modifiers.html -->
        <module name="ModifierOrder"/>
        <module name="RedundantModifier"/>
 
        <!-- Checks for blocks. You know, those {}'s         -->
        <!-- See http://checkstyle.sf.net/config_blocks.html -->
        <module name="AvoidNestedBlocks"/>
        <module name="EmptyBlock"/>
        <module name="LeftCurly"/>
        <module name="NeedBraces"/>
        <module name="RightCurly"/>
 
        <!-- Checks for common coding problems               -->
        <!-- See http://checkstyle.sf.net/config_coding.html -->
        <module name="AvoidInlineConditionals"/>
        <module name="EmptyStatement"/>
        <module name="EqualsHashCode"/>
        <!--module name="HiddenField"/-->
        <module name="IllegalInstantiation"/>
        <module name="InnerAssignment"/>
        <module name="MagicNumber"/>
        <module name="MissingSwitchDefault"/>
        <module name="SimplifyBooleanExpression"/>
        <module name="SimplifyBooleanReturn"/>
 
        <!-- Checks for class design                         -->
        <!-- See http://checkstyle.sf.net/config_design.html -->
        <!--module name="DesignForExtension"/-->
        <module name="FinalClass"/>
        <module name="HideUtilityClassConstructor"/>
        <module name="InterfaceIsType"/>
        <module name="VisibilityModifier"/>
 
        <!-- Miscellaneous other checks.                   -->
        <!-- See http://checkstyle.sf.net/config_misc.html -->
        <module name="ArrayTypeStyle"/>
        <module name="FinalParameters"/>
        <module name="TodoComment"/>
        <module name="UpperEll"/>
 
    </module>
 
</module>

JSTL (Java Standard Tag Libraries), using an implementation which doesn't potentially break your server.

        <dependency>
            <groupId>org.apache.taglibs</groupId>
            <artifactId>taglibs-standard-spec</artifactId>
            <version>1.2.5</version>
        </dependency>
        <dependency>
            <groupId>org.apache.taglibs</groupId>
            <artifactId>taglibs-standard-impl</artifactId>
            <version>1.2.5</version>
        </dependency>

Apache Tika (for textextraction purposes)

        <dependency>
            <groupId>org.apache.tika</groupId>
            <artifactId>tika-parsers</artifactId>
            <version>1.22</version>
        </dependency>

Hibernate search (for textsearching purposes / index)

<dependency>
   <groupId>org.hibernate</groupId>
   <artifactId>hibernate-search-orm</artifactId>
   <version>5.11.3.Final</version>
</dependency>

Hibernate validator for java < 8 (for validation purposes, also combine with jsoup to scan for scripts in html)

<dependency>
   <groupId>org.hibernate</groupId>
   <artifactId>hibernate-validator</artifactId>
   <version>5.4.3.Final</version>
</dependency>

Hibernate validator for java 8+ (for validation purposes, also combine with jsoup to scan for scripts in html)

<dependency>
   <groupId>org.hibernate</groupId>
   <artifactId>hibernate-validator</artifactId>
   <version>6.0.17.Final</version>
</dependency>

JSoup for scanning html

<dependency>
   <groupId>org.jsoup</groupId>
   <artifactId>jsoup</artifactId>
   <version>1.12.1</version>
</dependency>

We're going to set some properties in META-INF/context.xml
if path = ”/” it will deploy locally to your server root. To get the same result on a live server, you need to rename the war to ROOT.war.
if path = ”/applicationname” it will deploy locally to /applicationname. To get the same result on a live server, you need to rename the war to applicationname.war.

webAppRootKey: an identifier for the applciation, give it the value of your applicationname
database_user: make a database user like applicationname_user, you can make the same one on the live server (with same password).
database_catalog: applicationname
database_jdbc: notice extra options useSSL (false) and sendFractionalSeconds (false) for compatibility with mysql 5.7
searchindexPath: remove entry if not using hibernate search, change applicationname otherwise.
uploadPath: change applicationname, don't forget to create the path on server + locally. also make sure to chmod -R 777

context.xml

<?xml version="1.0" encoding="UTF-8"?>
<Context antiJARLocking="true" path="/">
    <Parameter name="webAppRootKey" value="applicationname" />
    <Parameter name="log4jConfiguration" value="/WEB-INF/log4j2.json" />
    <Parameter name="database_user" value="applicationname_user"/>
    <Parameter name="database_password" value="somethingcomplicated"/>
    <Parameter name="database_jdbc" value="jdbc:mysql://localhost:3306/?useUnicode=true&amp;characterEncoding=UTF-8&amp;useSSL=false&amp;sendFractionalSeconds=false&amp;serverTimezone=Europe/Berlin"/>
    <Parameter name="database_catalog" value="applicationname"/>
    <Parameter name="searchindexPath" value="/var/mentoringsystems/applicationname/index"/>
    <Parameter name="uploadPath" value="/var/mentoringsystems/applicationname"/>
    <Parameter name="email_host" value="mailserver"/>
    <Parameter name="email_port" value="587"/>
    <Parameter name="email_user" value="registration@merke.be"/>
    <Parameter name="email_pass" value="somethingcomplicated"/>
    <Parameter name="email_auth" value="true"/>
    <Parameter name="email_starttls" value="true"/>
    <Parameter name="email_from" value="registration@merke.be"/>
    <Parameter name="feedback_from" value="feedback@merke.be"/>
    <Parameter name="feedback_to" value="support@mentoringsystems.be"/>
    <Parameter name="app_url" value="https://merke.be/"/>
    <Parameter name="development" value="true"/>
</Context>

Now we need the following in our WEB-INF/web.xml
Don't forget to change applicationname.

web.xml

<?xml version="1.0" encoding="UTF-8"?>
<web-app xmlns="http://xmlns.jcp.org/xml/ns/javaee"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://xmlns.jcp.org/xml/ns/javaee 
         http://xmlns.jcp.org/xml/ns/javaee/web-app_3_1.xsd"
         version="3.1">
    <display-name>applicationname</display-name>
    <session-config>
        <session-timeout>
            30
        </session-timeout>
    </session-config>
</web-app>

We want to create a smaller application with less dependencies & less configuration (configuration by convention).
Properties which are app dependent can still be placed in META-INF/context.xml

AppConfiguration.java

package be.mentoringsystems.merke.config;
 
import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;
 
/**
 *
 * @author anthonyarents
 */
@Configuration
@ComponentScan({ "be.mentoringsystems.merke.*" })
@EnableScheduling
@Import({MvcConfiguration.class, DatabaseConfiguration.class, SecurityConfiguration.class, MessageConfiguration.class, MailConfiguration.class, AsyncConfiguration.class})
public class AppConfiguration {
 
}

MvcConfiguration.java

package be.mentoringsystems.merke.config;
 
import be.mentoringsystems.merke.presentation.locale.CustomLocaleResolver;
import com.fasterxml.jackson.databind.SerializationFeature;
import com.fasterxml.jackson.datatype.hibernate5.Hibernate5Module;
import com.fasterxml.jackson.datatype.jsr310.JavaTimeModule;
import com.fasterxml.jackson.datatype.jsr310.deser.LocalDateDeserializer;
import com.fasterxml.jackson.datatype.jsr310.deser.LocalDateTimeDeserializer;
import com.fasterxml.jackson.datatype.jsr310.ser.LocalDateTimeSerializer;
import java.nio.charset.Charset;
import java.time.LocalDate;
import java.time.LocalDateTime;
import java.time.format.DateTimeFormatter;
import java.util.List;
import java.util.Locale;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.core.Ordered;
import org.springframework.http.MediaType;
import org.springframework.http.converter.ByteArrayHttpMessageConverter;
import org.springframework.http.converter.HttpMessageConverter;
import org.springframework.http.converter.StringHttpMessageConverter;
import org.springframework.http.converter.json.Jackson2ObjectMapperBuilder;
import org.springframework.http.converter.json.MappingJackson2HttpMessageConverter;
import org.springframework.http.converter.xml.MappingJackson2XmlHttpMessageConverter;
import org.springframework.web.multipart.support.StandardServletMultipartResolver;
import org.springframework.web.servlet.LocaleResolver;
import org.springframework.web.servlet.config.annotation.ContentNegotiationConfigurer;
import org.springframework.web.servlet.config.annotation.CorsRegistry;
import org.springframework.web.servlet.config.annotation.DefaultServletHandlerConfigurer;
import org.springframework.web.servlet.config.annotation.EnableWebMvc;
import org.springframework.web.servlet.config.annotation.InterceptorRegistry;
import org.springframework.web.servlet.config.annotation.ResourceHandlerRegistry;
import org.springframework.web.servlet.config.annotation.ViewControllerRegistry;
import org.springframework.web.servlet.config.annotation.ViewResolverRegistry;
import org.springframework.web.servlet.config.annotation.WebMvcConfigurer;
import org.springframework.web.servlet.i18n.LocaleChangeInterceptor;
 
/**
 *
 * @author anthonyarents
 */
@Configuration
@EnableWebMvc
public class MvcConfiguration implements WebMvcConfigurer {
 
    private static final int COOKIE_MAX_AGE = 4800;
    private static final int CACHEPERIOD_IMAGES = 2678400;
    private static final int CACHEPERIOD_JS = 604800;
    @Value("#{contextParameters.development}")
    private Boolean development;
 
    @Override
    public void configureDefaultServletHandling(final DefaultServletHandlerConfigurer configurer) {
        configurer.enable();
    }
 
    @Override
    public void configureContentNegotiation(final ContentNegotiationConfigurer configurer) {
        configurer.favorPathExtension(false).favorParameter(true);
        configurer.defaultContentType(MediaType.TEXT_PLAIN);
        configurer.useRegisteredExtensionsOnly(true);
        configurer.mediaType("txt", MediaType.TEXT_PLAIN);
        configurer.mediaType("json", MediaType.APPLICATION_JSON);
        configurer.mediaType("xml", MediaType.APPLICATION_XML);
        configurer.mediaType("html", MediaType.TEXT_HTML);
    }
 
    @Override
    public void configureMessageConverters(final List<HttpMessageConverter<?>> converters) {
        final Hibernate5Module hibernate5Module = new Hibernate5Module();
        hibernate5Module.configure(Hibernate5Module.Feature.FORCE_LAZY_LOADING, false);
        hibernate5Module.configure(Hibernate5Module.Feature.USE_TRANSIENT_ANNOTATION, false);
 
        final JavaTimeModule javaTimeModule = new JavaTimeModule();
 
        final DateTimeFormatter localDateTimeFormatter = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss");
        javaTimeModule.addDeserializer(LocalDate.class, new LocalDateDeserializer(DateTimeFormatter.ofPattern("yyyy-MM-dd")));
        javaTimeModule.addDeserializer(LocalDateTime.class, new LocalDateTimeDeserializer(localDateTimeFormatter));
        javaTimeModule.addSerializer(LocalDateTime.class, new LocalDateTimeSerializer(localDateTimeFormatter));
 
        final Jackson2ObjectMapperBuilder builder = new Jackson2ObjectMapperBuilder();
        builder.indentOutput(true);
        builder.defaultViewInclusion(true);
        builder.modules(hibernate5Module, javaTimeModule);
        builder.featuresToDisable(SerializationFeature.WRITE_DATES_AS_TIMESTAMPS);
 
        converters.add(new MappingJackson2HttpMessageConverter(builder.build()));
 
        final StringHttpMessageConverter stringMessageConverter = new StringHttpMessageConverter(Charset.forName("UTF-8"));
        stringMessageConverter.setWriteAcceptCharset(false);
        converters.add(stringMessageConverter);
 
        converters.add(new MappingJackson2XmlHttpMessageConverter(builder.createXmlMapper(true).build()));
        converters.add(new ByteArrayHttpMessageConverter());
 
    }
 
    @Override
    public void addResourceHandlers(final ResourceHandlerRegistry registry) {
        // images
        registry.addResourceHandler("/static/favicon/**").addResourceLocations("/static/favicon/").setCachePeriod(CACHEPERIOD_IMAGES);
        registry.addResourceHandler("/static/**").addResourceLocations("/static/").setCachePeriod(604800);
 
        if (Boolean.TRUE.equals(development)) {
            // development
            registry.addResourceHandler("/static/Merke/**").addResourceLocations("/static/Merke/").setCachePeriod(CACHEPERIOD_JS);
            registry.addResourceHandler("/staticresources/**").addResourceLocations("/staticresources/").setCachePeriod(604800);
            registry.addResourceHandler("/build/classic/resources/**").addResourceLocations("/build/classic/resources/").setCachePeriod(604800);
            registry.addResourceHandler("/build/modern/resources/**").addResourceLocations("/build/modern/resources/").setCachePeriod(604800);
            registry.addResourceHandler("/build/resources/**").addResourceLocations("/build/resources/").setCachePeriod(604800);
            registry.addResourceHandler("/**").addResourceLocations("/static/Merke/").setCachePeriod(604800);
        } else {
            // production
            registry.addResourceHandler("/static/Merke/**").addResourceLocations("/static/Merke/").setCachePeriod(CACHEPERIOD_JS);
            registry.addResourceHandler("/staticresources/**").addResourceLocations("/staticresources/").setCachePeriod(604800);
            registry.addResourceHandler("/**").addResourceLocations("/build/").setCachePeriod(604800);
        }
    }
 
    @Override
    public void configureViewResolvers(final ViewResolverRegistry registry) {
        registry.jsp("/WEB-INF/jsp/", ".jsp");
    }
 
    @Override
    public void addViewControllers(final ViewControllerRegistry registry) {
        registry.addViewController("/").setViewName("forward:/index.html");
        registry.addViewController("/login").setViewName("redirect:/");
        registry.addViewController("/favicon.ico").setViewName("forward:/static/favicon/favicon.ico");
        registry.setOrder(Ordered.HIGHEST_PRECEDENCE);
    }
 
    @Bean
    public LocaleResolver localeResolver() {
        CustomLocaleResolver resolver = new CustomLocaleResolver();
        resolver.setDefaultLocale(new Locale("nl"));
        resolver.setCookieName("myLocaleCookie");
        resolver.setCookieMaxAge(COOKIE_MAX_AGE);
        return resolver;
    }
 
    @Bean
    public LocaleChangeInterceptor localeChangeInterceptor() {
        LocaleChangeInterceptor interceptor = new LocaleChangeInterceptor();
        interceptor.setParamName("mylocale");
        return interceptor;
    }
 
    @Override
    public void addInterceptors(final InterceptorRegistry registry) {
        registry.addInterceptor(localeChangeInterceptor());
    }
 
    @Bean(name = "multipartResolver")
    public StandardServletMultipartResolver multipartResolver() {
        return new StandardServletMultipartResolver();
    }
 
    @Override
    public void addCorsMappings(final CorsRegistry registry) {
        registry.addMapping("/**");
    }
 
}

DatabaseConfiguration.java

package be.mentoringsystems.merke.config;
 
import java.util.Properties;
import javax.sql.DataSource;
import org.apache.commons.dbcp2.BasicDataSource;
import org.hibernate.SessionFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.orm.hibernate5.HibernateTransactionManager;
import org.springframework.orm.hibernate5.LocalSessionFactoryBean;
import org.springframework.transaction.annotation.EnableTransactionManagement;
 
/**
 *
 * @author anthonyarents
 */
@Configuration
@EnableTransactionManagement
public class DatabaseConfiguration {
 
    @Value("#{contextParameters.database_catalog}")
    private String dbName;
    @Value("#{contextParameters.database_user}")
    private String dbUser;
    @Value("#{contextParameters.database_password}")
    private String dbPass;
    @Value("#{contextParameters.database_jdbc}")
    private String dbJdbc;
    @Value("#{contextParameters.searchindexPath}")
    private String searchindexPath;
 
    private static final int DSPOOL_MAX_IDLE = 17;
    private static final int DSPOOL_MAX_TOTAL = 20;
    private static final int DSPOOL_MAX_WAIT_MILLIS = 10000;
 
    @Bean
    public DataSource dataSource() {
        final BasicDataSource bds = new BasicDataSource();
        bds.setUsername(dbUser);
        bds.setPassword(dbPass);
        bds.setDefaultCatalog(dbName);
        bds.setUrl(dbJdbc);
        bds.setDriverClassName("com.mysql.cj.jdbc.Driver");
        bds.setMaxIdle(DSPOOL_MAX_IDLE);
        bds.setMaxTotal(DSPOOL_MAX_TOTAL);
        bds.setMaxWaitMillis(DSPOOL_MAX_WAIT_MILLIS);
        bds.setValidationQuery("SELECT 1;");
        bds.setTestOnBorrow(true);
        bds.setRemoveAbandonedOnBorrow(true);
        return bds;
    }
 
    private Properties getHibernateProperties() {
        Properties properties = new Properties();
        properties.put("hibernate.dialect", "org.hibernate.dialect.MySQL5Dialect");
        properties.put("hibernate.show_sql", false);
        properties.put("hibernate.format_sql", false);
        properties.put("hibernate.connection.useUnicode", true);
        properties.put("hibernate.connection.characterEncoding", "utf8");
        properties.put("hibernate.connection.charSet", "utf8");
        properties.put("hibernate.search.default.directory_provider", "filesystem");
        properties.put("hibernate.search.default.indexBase", searchindexPath);
        return properties;
    }
 
    @Bean
    public LocalSessionFactoryBean sessionFactory() {
        LocalSessionFactoryBean sessionFactory = new LocalSessionFactoryBean();
        sessionFactory.setDataSource(dataSource());
        sessionFactory.setAnnotatedPackages(new String[]{"be.mentoringsystems.merke.model.db"});
        sessionFactory.setPackagesToScan(new String[]{"be.mentoringsystems.merke.model.db"});
        sessionFactory.setHibernateProperties(getHibernateProperties());
        return sessionFactory;
    }
 
    @Bean
    @Autowired
    public HibernateTransactionManager transactionManager(final SessionFactory s) {
        HibernateTransactionManager txManager = new HibernateTransactionManager();
        txManager.setSessionFactory(s);
        return txManager;
    }
}

SecurityConfiguration.java

package be.mentoringsystems.merke.config;
 
import be.mentoringsystems.merke.security.JWTAuthenticationFilter;
import be.mentoringsystems.merke.service.LoginService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Bean;
import org.springframework.security.config.annotation.authentication.builders.AuthenticationManagerBuilder;
import org.springframework.security.config.annotation.method.configuration.EnableGlobalMethodSecurity;
import org.springframework.security.config.annotation.web.builders.HttpSecurity;
import org.springframework.security.config.annotation.web.builders.WebSecurity;
import org.springframework.security.config.annotation.web.configuration.EnableWebSecurity;
import org.springframework.security.config.annotation.web.configuration.WebSecurityConfigurerAdapter;
import org.springframework.security.crypto.factory.PasswordEncoderFactories;
import org.springframework.security.crypto.password.PasswordEncoder;
import org.springframework.security.web.authentication.switchuser.SwitchUserFilter;
import org.springframework.security.web.authentication.www.BasicAuthenticationFilter;
 
/**
 *
 * @author anthonyarents
 */
@EnableWebSecurity
@EnableGlobalMethodSecurity(prePostEnabled = true)
public class SecurityConfiguration extends WebSecurityConfigurerAdapter {
 
    @Autowired
    private LoginService loginService;
    @Autowired
    private JWTAuthenticationFilter jwtAuthenticationFilter;
 
    @Override
    public void configure(final WebSecurity web) throws Exception {
        web.ignoring().antMatchers("/static/**", "/classic/**", "/app/**", "/production/**", "/Merke/**");
    }
 
    @Override
    protected void configure(final HttpSecurity http) throws Exception {
        // temporary
        http.csrf().disable();
        http.headers().frameOptions().sameOrigin();
        http.userDetailsService(loginService);
        http
                .addFilter(switchUserFilter())
                .addFilterAfter(jwtAuthenticationFilter, BasicAuthenticationFilter.class)
                //.formLogin()
                //.loginPage("/login").defaultSuccessUrl("/", false).failureUrl("/login?error").permitAll() //login page, redirect tologinrequired page if there was one, permitall is necessary
                //.and()
                .logout().logoutUrl("/logout").logoutSuccessUrl("/").permitAll() // logout page, permitall is necessary
                .and()
                .authorizeRequests() // request matching with ant
                .antMatchers("/**").permitAll()
                .antMatchers("/login/**").permitAll()
                .antMatchers("/logins/authenticate").permitAll()
                .antMatchers("/register").permitAll()
                .antMatchers("/categories").permitAll()
                .antMatchers("/venues").permitAll()
                .antMatchers("/privateVenues").permitAll()
                .antMatchers("/recoverPassword").anonymous()
                .antMatchers("/passwordrecovery").anonymous()
                .antMatchers("/switchuser").hasRole("MSADMIN")
                .anyRequest().authenticated(); // all remaining requests need login
    }
 
    @Bean(name = "switchUserFilter")
    public SwitchUserFilter switchUserFilter() {
        final SwitchUserFilter filter = new SwitchUserFilter();
        filter.setUserDetailsService(loginService);
        filter.setExitUserUrl("/exituser");
        filter.setSwitchUserUrl("/switchuser");
        filter.setTargetUrl("/");
        filter.setUsernameParameter("username");
        return filter;
    }
 
    @Bean
    public PasswordEncoder passwordEncoder() {
        return PasswordEncoderFactories.createDelegatingPasswordEncoder();
    }
 
    @Override
    protected void configure(final AuthenticationManagerBuilder auth) throws Exception {
        auth.userDetailsService(loginService).passwordEncoder(passwordEncoder());
    }
 
}

removes web.xml config: the servlet code

SpringConfigurationInitializer.java

package be.trustandchain.mobi.config.initializer;
 
import be.mentoringsystems.merke.config.AppConfiguration;
import javax.servlet.MultipartConfigElement;
import javax.servlet.ServletRegistration;
import org.springframework.web.servlet.support.AbstractAnnotationConfigDispatcherServletInitializer;
 
/**
 *
 * @author anthonyarents
 */
public class SpringConfigurationInitializer extends AbstractAnnotationConfigDispatcherServletInitializer {
 
    @Override
    protected Class<?>[] getRootConfigClasses() {
        return new Class[]{AppConfiguration.class};
    }
 
    @Override
    protected Class<?>[] getServletConfigClasses() {
        return null;
    }
 
    @Override
    protected String[] getServletMappings() {
        return new String[]{"/"};
    }
 
    @Override
    protected void customizeRegistration(final ServletRegistration.Dynamic registration) {
        MultipartConfigElement multipartConfigElement = new MultipartConfigElement("/tmp", mb(50), mb(70), 0);
        registration.setMultipartConfig(multipartConfigElement);
    }
 
    private long mb(final long nr) {
        // 1024 * 1024
        return nr * 1048576;
    }
 
}

removes web.xml config: filterchain

SpringSecurityInitializer.java

package be.mentoringsystems.merke.config.initializer;
 
import org.springframework.security.web.context.AbstractSecurityWebApplicationInitializer;
 
/**
 *
 * @author anthonyarents
 */
public class SpringSecurityInitializer extends AbstractSecurityWebApplicationInitializer {
 
}

These are examples of extra configuration. The class needs to be added to AppConfiguration's @Import !

used for configuring a javamailer

MailConfiguration.java

package be.mentoringsystems.merke.config;
 
import java.util.Properties;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.mail.javamail.JavaMailSender;
import org.springframework.mail.javamail.JavaMailSenderImpl;
 
/**
 *
 * @author anthonyarents
 */
@Configuration
public class MailConfiguration {
 
    @Value("#{contextParameters.email_host}")
    private String host;
    @Value("#{contextParameters.email_user}")
    private String user;
    @Value("#{contextParameters.email_pass}")
    private String pass;
    @Value("#{contextParameters.email_port}")
    private Integer port;
    @Value("#{contextParameters.email_auth}")
    private Boolean auth;
    @Value("#{contextParameters.email_starttls}")
    private Boolean starttls;
 
    @Bean(name = "javaMailService")
    public JavaMailSender javaMailService() {
        JavaMailSenderImpl javaMailSender = new JavaMailSenderImpl();
        javaMailSender.setDefaultEncoding("UTF-8");
        javaMailSender.setHost(host);
        javaMailSender.setUsername(user);
        javaMailSender.setPassword(pass);
        javaMailSender.setPort(port);
        final Properties properties = new Properties();
        properties.setProperty("mail.smtp.auth", Boolean.toString(auth));
        properties.setProperty("mail.smtp.starttls.enable", Boolean.toString(starttls));
        javaMailSender.setJavaMailProperties(properties);
        return javaMailSender;
    }
}

used for translation messages

MessageConfiguration.java

package be.mentoringsystems.merke.config;
 
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.support.ResourceBundleMessageSource;
 
/**
 *
 * @author anthonyarents
 */
@Configuration
public class MessageConfiguration {
 
    @Bean
    public ResourceBundleMessageSource messageSource() {
        ResourceBundleMessageSource source = new ResourceBundleMessageSource();
        source.setBasename("i18n/messages");
        source.setUseCodeAsDefaultMessage(true);
        return source;
    }
}

used for async method configuration, with this it's possible to use @Async for methods you want to run async
(like the method in charge of sending a mail).

AsyncConfiguration.java

package be.mentoringsystems.merke.config;
 
import java.util.concurrent.Executor;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.scheduling.TaskScheduler;
import org.springframework.scheduling.annotation.AsyncConfigurerSupport;
import org.springframework.scheduling.annotation.EnableAsync;
import org.springframework.scheduling.concurrent.ConcurrentTaskScheduler;
import org.springframework.scheduling.concurrent.ThreadPoolTaskExecutor;
 
/**
 *
 * @author anthonyarents
 */
@Configuration
@EnableAsync
public class AsyncConfiguration extends AsyncConfigurerSupport {
 
    @Bean
    public TaskScheduler taskScheduler() {
        return new ConcurrentTaskScheduler();
    }
 
    @Override
    public Executor getAsyncExecutor() {
        ThreadPoolTaskExecutor executor = new ThreadPoolTaskExecutor();
        executor.setCorePoolSize(2);
        executor.setMaxPoolSize(2);
        executor.setQueueCapacity(100);
        executor.setThreadNamePrefix("Async-");
        executor.setAwaitTerminationSeconds(10);
        executor.initialize();
        return executor;
    }
}

Sometimes, we want certain beans to be used in production but not in test, activate blockchain or disable it, …
We can do this by implementing Condition, in this condition we check the contextParameters, the same code can be used to check
environment variables etc.

BlockchainUsageCondition.java

package be.trustandchain.mobi.condition;
 
import org.springframework.context.annotation.Condition;
import org.springframework.context.annotation.ConditionContext;
import org.springframework.core.type.AnnotatedTypeMetadata;
 
/**
 *
 * @author anthonyarents
 */
public class BlockchainUsageCondition implements Condition {
 
    @Override
    public boolean matches(final ConditionContext cc, final AnnotatedTypeMetadata atm) {
        String value = cc.getEnvironment().getProperty("use_blockchain");
        return "true".equals(value);
    }
 
}

Classes annotated with @Conditional will only be in effect IF the condition returns true :

import org.springframework.context.annotation.Conditional;
 
@Repository
@Conditional(BlockchainUsageCondition.class)
public class CommentDAOImpl implements CommentDAO { ... }

Create a database WITH utf8-bin (case sensitive)

Login.sql

CREATE TABLE `Login` (
  `id` BINARY(36) NOT NULL,
  `firstname` VARCHAR(200) COLLATE utf8_bin NOT NULL,
  `lastname` VARCHAR(200) COLLATE utf8_bin NOT NULL,
  `email` VARCHAR(400) COLLATE utf8_bin NOT NULL,
  `password` BINARY(60) NOT NULL,
  `group` INT(1) NOT NULL,
  `username` VARCHAR(200) COLLATE utf8_bin NOT NULL,
  `deleted` CHAR(1) COLLATE utf8_bin NOT NULL DEFAULT 'N',
  `active` CHAR(1) COLLATE utf8_bin NOT NULL DEFAULT 'Y',
  `createdOn` TIMESTAMP NOT NULL DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP
) ENGINE=InnoDB DEFAULT CHARSET=utf8 COLLATE=utf8_bin;
 
ALTER TABLE `Login`
  ADD PRIMARY KEY (`id`),
  ADD KEY `username` (`username`);

QueryParams.java

package be.mentoringsystems.merke.model;
 
import be.mentoringsystems.merke.helper.ConversionHelper;
import com.fasterxml.jackson.annotation.JsonAnySetter;
import java.util.ArrayList;
import java.util.List;
import org.apache.commons.lang3.StringUtils;
 
/**
 *
 * @author anthonyarents
 */
public class QueryParams {
 
    private int start = 0;
    private int limit = 0;
    private FilterMap filter = new FilterMap();
    private SortingMap sort = new SortingMap();
    private List<String> initializeExtra = new ArrayList<String>();
 
    // return message can be used to return statusses like "data generated" to other methods.
    private String returnmessage;
 
    public String getReturnmessage() {
        return returnmessage;
    }
 
    public void setReturnmessage(final String returnmessage) {
        this.returnmessage = returnmessage;
    }
 
    public String getLoadConfig() {
        return ConversionHelper.toString(this.getFilterValue("loadconfig"));
    }
 
    public void setLoadConfig(final String val) {
        this.addFilter("loadconfig", val);
    }
 
    public List<String> getInitializeExtra() {
        return initializeExtra;
    }
 
    public void setInitializeExtra(final List<String> initializeExtra) {
        this.initializeExtra = initializeExtra;
    }
 
    public void addInitializeExtra(final String property) {
        this.initializeExtra.add(property);
    }
 
    public FilterMap getFilter() {
        return filter;
    }
 
    public void setFilter(final FilterMap filter) {
        this.filter = filter;
    }
 
    public void setSearch(final String search) {
        this.addFilter("search", search);
    }
 
    @JsonAnySetter
    public void addFilter(final String property, final Object value) {
        if (!StringUtils.isEmpty(property) && !StringUtils.startsWith(property, "_")) {
            Filter filter = getFilter(property);
            if (filter == null) {
                filter = new Filter();
                filter.setProperty(property);
                filter.setValue(value);
                this.filter.addFilter(filter);
            } else {
                filter.setValue(value);
            }
        }
    }
 
    public void addSorting(final String property, final String direction) {
        if (!StringUtils.isEmpty(property)) {
            Sorting sorting = new Sorting();
            sorting.setProperty(property);
            sorting.setDirection(direction);
            getSort().getSortings().add(sorting);
        }
    }
 
    public Filter getFilter(final String property) {
        if (this.getFilter() == null) {
            return null;
        } else {
            return this.filter.getFilter(property);
        }
    }
 
    public Object getFilterValue(final String property) {
        if (this.getFilter() == null) {
            return null;
        } else {
            return this.getFilter().getValue(property);
        }
    }
 
    public int getLimit() {
        return limit;
    }
 
    public void setLimit(final int limit) {
        this.limit = limit;
    }
 
    public SortingMap getSort() {
        return sort;
    }
 
    public void setSort(final SortingMap sort) {
        this.sort = sort;
    }
 
    public int getStart() {
        return start;
    }
 
    public void setStart(final int start) {
        this.start = start;
    }
}

FilterMap.java

package be.mentoringsystems.merke.model;
 
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
 
/**
 *
 * @author anthonyarents
 */
public class FilterMap {
 
    private List<Filter> filters = new ArrayList<Filter>();
    private Map<String, Filter> map = new HashMap<String, Filter>();
 
    public List<Filter> getFilters() {
        return filters;
    }
 
    public void setFilters(final List<Filter> filters) {
        this.filters = filters;
    }
 
    public void addFilter(final Filter filter) {
        this.filters.add(filter);
        this.map.put(filter.getProperty(), filter);
    }
 
    public Map<String, Filter> getMap() {
        return map;
    }
 
    public void setMap(final Map<String, Filter> map) {
        this.map = map;
    }
 
    public Filter getFilter(final String property) {
        return map.get(property);
    }
 
    public Object getValue(final String property) {
        final Filter result = getFilter(property);
        if (result == null) {
            return null;
        } else {
            return result.getValue();
        }
    }
}

Filter.java

package be.mentoringsystems.merke.model;
 
/**
 *
 * @author anthonyarents
 */
public class Filter {
 
    private String property;
    private Object value;
 
    public String getProperty() {
        return property;
    }
 
    public void setProperty(final String property) {
        this.property = property;
    }
 
    public Object getValue() {
        return value;
    }
 
    public void setValue(final Object value) {
        this.value = value;
    }
}

SortingMap.java

package be.mentoringsystems.merke.model;
 
import java.util.ArrayList;
import java.util.List;
 
/**
 *
 * @author anthonyarents
 */
public class SortingMap {
 
    private List<Sorting> sortings = new ArrayList<>();
 
    public List<Sorting> getSortings() {
        return sortings;
    }
 
    public void setSortings(final List<Sorting> sortings) {
        this.sortings = sortings;
    }
}

Sorting.java

package be.mentoringsystems.merke.model;
 
/**
 *
 * @author anthonyarents
 */
public class Sorting {
 
    private String property;
    private String direction;
 
    public String getDirection() {
        return direction;
    }
 
    public void setDirection(final String direction) {
        this.direction = direction;
    }
 
    public String getProperty() {
        return property;
    }
 
    public void setProperty(final String property) {
        this.property = property;
    }
}

ConversionHelper.java

package be.mentoringsystems.merke.helper;
 
import java.time.LocalDate;
import java.time.LocalDateTime;
import java.time.format.DateTimeFormatter;
import java.util.ArrayList;
import java.util.List;
import java.util.UUID;
import javax.annotation.Nullable;
import org.apache.commons.lang3.math.NumberUtils;
 
/**
 *
 * @author anthonyarents
 */
public final class ConversionHelper {
 
    private static final DateTimeFormatter LOCALDATEFORMATTER = DateTimeFormatter.ofPattern("yyyy-MM-dd");
    private static final DateTimeFormatter LOCALDATETIMEFORMATTER = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss");
 
    private ConversionHelper() {
    }
 
    @SuppressWarnings("unchecked")
    public static List<Object> toObjectList(final Object obj) {
        List<Object> result = new ArrayList<Object>();
        if (obj == null) {
            return result;
        }
        if (obj instanceof List) {
            return (List<Object>) obj;
        } // assume it's always a list of string, this is done by spring automatically ...
        result.add(obj);
        return result;
    }
 
    @SuppressWarnings("unchecked")
    public static List<String> toStringList(final Object obj) {
        List<String> result = new ArrayList<String>();
        if (obj == null) {
            return result;
        }
        if (obj instanceof List) {
            return (List<String>) obj;
        } // assume it's always a list of string, this is done by spring automatically ...
        if (obj instanceof String) {
            result.add((String) obj);
        }
        return result;
    }
 
    @SuppressWarnings("unchecked")
    public static List<Integer> toIntegerList(final Object obj) {
        List<Integer> result = new ArrayList<Integer>();
        if (obj == null) {
            return result;
        }
        if (obj instanceof List) {
            return (List<Integer>) obj;
        } // assume it's always a list of integer, this is done by spring automatically ...
        if (obj instanceof Integer) {
            result.add((Integer) obj);
        }
        return result;
    }
 
    public static List<UUID> toUUIDList(final Object obj) {
        List<UUID> result = new ArrayList<UUID>();
        if (obj == null) {
            return result;
        }
        List<Object> start = toObjectList(obj);
        for (Object o : start) {
            UUID u = toUUID(o);
            if (u != null) {
                result.add(u);
            }
        }
        return result;
    }
 
    public static UUID toUUID(final Object obj) {
        if (obj == null) {
            return null;
        }
        if (obj instanceof UUID) {
            return (UUID) obj;
        }
        return UUID.fromString(toString(obj));
    }
 
    public static String toString(final Object obj) {
        if (obj == null) {
            return null;
        }
        if (obj instanceof String) {
            return (String) obj;
        }
        return obj.toString();
    }
 
    public static LocalDate toLocalDate(final Object obj) {
        if (obj == null) {
            return null;
        }
        if (obj instanceof LocalDate) {
            return (LocalDate) obj;
        }
        String dateString = toString(obj);
        if (dateString == null) {
            return null;
        } else {
            return (LocalDate) LOCALDATEFORMATTER.parse(dateString);
        }
    }
 
    public static LocalDateTime toLocalDateTime(final Object obj) {
        if (obj == null) {
            return null;
        }
        if (obj instanceof LocalDateTime) {
            return (LocalDateTime) obj;
        }
        String dateString = toString(obj);
        if (dateString == null) {
            return null;
        } else {
            return (LocalDateTime) LOCALDATETIMEFORMATTER.parse(dateString);
        }
    }
 
    public static Integer toInteger(final Object obj) {
        if (obj == null) {
            return null;
        }
        if (obj instanceof Integer) {
            return (Integer) obj;
        }
        return NumberUtils.toInt(toString(obj));
    }
 
    @Nullable
    public static Boolean toBoolean(final Object obj) {
        if (obj == null) {
            return null;
        }
        if (obj instanceof Boolean) {
            return (Boolean) obj;
        }
        String objString = toString(obj);
        if ("1".equals(objString) || "true".equals(objString)) {
            return Boolean.TRUE;
        }
        return Boolean.FALSE;
    }
}

DTOHelper.java

package be.mentoringsystems.merke.helper;
 
import java.lang.reflect.InvocationTargetException;
import java.util.Collection;
import java.util.Collections;
import java.util.Map;
import java.util.logging.Level;
import java.util.logging.Logger;
import org.apache.commons.beanutils.BeanUtils;
import org.apache.commons.beanutils.PropertyUtils;
 
/**
 *
 * @author anthonyarents
 */
public final class DTOHelper {
 
    private DTOHelper() {
    }
 
    public static void copyNonNull(final Object source, final Object target) {
        try {
            Map<String, Object> sourceValues = PropertyUtils.describe(source);
            Collection<Object> values = sourceValues.values();
            values.removeAll(Collections.singleton(null));
            populate(sourceValues, target);
        } catch (IllegalAccessException | InvocationTargetException | NoSuchMethodException ex) {
            Logger.getLogger(DTOHelper.class.getName()).log(Level.SEVERE, null, ex);
        }
    }
 
    public static void copy(final Object source, final Object target) {
        try {
            Map<String, Object> sourceValues = PropertyUtils.describe(source);
            populate(sourceValues, target);
        } catch (IllegalAccessException | InvocationTargetException | NoSuchMethodException ex) {
            Logger.getLogger(DTOHelper.class.getName()).log(Level.SEVERE, null, ex);
        }
    }
 
    public static void populate(final Map<String, Object> source, final Object target) throws IllegalAccessException, InvocationTargetException {
        BeanUtils.populate(target, source);
    }
}

Of note :

• implements UserDetails (Spring Security)
• Uses JsonView, IF we want to have a specific view, we want to mark all “public” fields with the “View.Public”
  class and the “private” fields with a class which extends “View.Public” class, preferably “View.<Model>”

Login.java

package be.mentoringsystems.merke.model.db;
 
import be.mentoringsystems.merke.model.dto.View;
import com.fasterxml.jackson.annotation.JsonFormat;
import com.fasterxml.jackson.annotation.JsonIgnore;
import com.fasterxml.jackson.annotation.JsonView;
import java.io.Serializable;
import java.time.LocalDateTime;
import java.util.ArrayList;
import java.util.Collection;
import java.util.List;
import java.util.UUID;
import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.Id;
import javax.persistence.Transient;
import org.hibernate.annotations.Type;
import org.springframework.security.core.GrantedAuthority;
import org.springframework.security.core.userdetails.UserDetails;
 
/**
 *
 * @author anthonyarents
 */
@Entity
public class Login implements UserDetails, Serializable {
 
    private static final long serialVersionUID = -5435867605493271271L;
    private UUID id;
    private String firstname;
    private String lastname;
    private String email;
    private String password;
    private Integer group = 2;
    private String username;
    private boolean deleted = false;
    private boolean active = false;
    private LocalDateTime createdOn = LocalDateTime.now();
    private List<GrantedAuthority> authorities = new ArrayList<GrantedAuthority>();
 
    @JsonIgnore
    @Column
    @Type(type = "yes_no")
    public boolean isDeleted() {
        return deleted;
    }
 
    public void setDeleted(boolean deleted) {
        this.deleted = deleted;
    }
 
    @JsonView(View.Public.class)
    @Id
    @Column
    @GeneratedValue( generator = "uuid" )
    @Type(type = "uuid-char")
    public UUID getId() {
        return id;
    }
 
    public void setId(final UUID id) {
        this.id = id;
    }
 
    @JsonView(View.Login.class)
    @Column
    public LocalDateTime getCreatedOn() {
        return createdOn;
    }
 
    public void setCreatedOn(final LocalDateTime createdOn) {
        this.createdOn = createdOn;
    }
 
    @JsonView(View.Login.class)
    @Column
    public String getEmail() {
        return email;
    }
 
    public void setEmail(final String email) {
        this.email = email;
    }
 
    @JsonView(View.Public.class)
    @Column
    public String getFirstname() {
        return firstname;
    }
 
    public void setFirstname(final String firstname) {
        this.firstname = firstname;
    }
 
    @JsonView(View.Login.class)
    @Column(name="`group`", nullable = false)
    public Integer getGroup() {
        return group;
    }
 
    public void setGroup(Integer group) {
        this.group = group;
    }
 
    @JsonView(View.Public.class)
    @Column
    public String getLastname() {
        return lastname;
    }
 
    public void setLastname(final String lastname) {
        this.lastname = lastname;
    }
 
    @JsonView(View.Login.class)
    @Column
    @Override
    public String getUsername() {
        return username;
    }
 
    public void setUsername(String username) {
        this.username = username;
    }
 
    @JsonIgnore
    @Column(nullable = false)
    @Override
    public String getPassword() {
        return password;
    }
 
    public void setPassword(final String password) {
        this.password = password;
    }
 
    @JsonView(View.Login.class)
    @Column
    @Type(type = "yes_no")
    public boolean isActive() {
        return active;
    }
 
    public void setActive(boolean active) {
        this.active = active;
    }
 
    @JsonIgnore
    @Override
    @Transient
    public Collection<? extends GrantedAuthority> getAuthorities() {
        return authorities;
    }
 
    public void setAuthorities(List<GrantedAuthority> authorities) {
        this.authorities = authorities;
    }
 
    @JsonIgnore
    @Override
    @Transient
    public boolean isAccountNonExpired() {
        return true;
    }
 
    @JsonIgnore
    @Override
    @Transient
    public boolean isAccountNonLocked() {
        return true;
    }
 
    @JsonIgnore
    @Override
    @Transient
    public boolean isCredentialsNonExpired() {
        return true;
    }
 
    @JsonIgnore
    @Override
    @Transient
    public boolean isEnabled() {
        return this.isActive();
    }
}

Important : “package-info.java” with uuid generator, to be added to model.db

package-info.java

@GenericGenerator(
        name = "uuid",
        strategy = "org.hibernate.id.UUIDGenerator",
        parameters = {
            @Parameter(
                    name = "uuid_gen_strategy_class",
                    value = "org.hibernate.id.uuid.CustomVersionOneStrategy"
            )
        }
)
@FilterDef(name = "deletedObjectsFilter", defaultCondition = "deleted = 'N'")
package be.mentoringsystems.merke.model.db;
 
import org.hibernate.annotations.FilterDef;
import org.hibernate.annotations.GenericGenerator;
import org.hibernate.annotations.Parameter;

Context.java

package de.jcpis.analysestats.model.db;
 
import java.io.Serializable;
import java.util.UUID;
import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.FetchType;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;
import javax.persistence.JoinColumn;
import javax.persistence.ManyToOne;
import org.hibernate.annotations.Type;
 
/**
 *
 * @author anthonyarents
 */
@Entity
public class Context implements Serializable {
 
    private static final long serialVersionUID = -7951893343401921083L;
    private Integer id;
    private Integer serverId;
    private Server server;
    private UUID contextId;
    private UUID parentContextId;
    private String name;
    private Integer beraterCount;
    private Integer mandantCount;
    private Integer assetCount;
    private Integer syncCount;
    private boolean hidden = false;
 
    @Id
    @Column
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    public Integer getId() {
        return id;
    }
 
    public void setId(Integer id) {
        this.id = id;
    }
 
    @Column(insertable = false, updatable = false)
    public Integer getServerId() {
        return serverId;
    }
 
    public void setServerId(Integer serverId) {
        this.serverId = serverId;
    }
 
    @ManyToOne(fetch = FetchType.LAZY)
    @JoinColumn(name = "serverId")
    public Server getServer() {
        return server;
    }
 
    public void setServer(Server server) {
        this.server = server;
    }
 
    @Column
    public String getName() {
        return name;
    }
 
    public void setName(String name) {
        this.name = name;
    }
 
    @Column
    public Integer getBeraterCount() {
        return beraterCount;
    }
 
    public void setBeraterCount(Integer beraterCount) {
        this.beraterCount = beraterCount;
    }
 
    @Column
    public Integer getMandantCount() {
        return mandantCount;
    }
 
    public void setMandantCount(Integer mandantCount) {
        this.mandantCount = mandantCount;
    }
 
    @Column
    public Integer getAssetCount() {
        return assetCount;
    }
 
    public void setAssetCount(Integer assetCount) {
        this.assetCount = assetCount;
    }
 
    @Column
    public Integer getSyncCount() {
        return syncCount;
    }
 
    public void setSyncCount(Integer syncCount) {
        this.syncCount = syncCount;
    }
 
    @Column
    @Type(type = "uuid-char")
    public UUID getContextId() {
        return contextId;
    }
 
    public void setContextId(UUID contextId) {
        this.contextId = contextId;
    }
 
    @Column
    @Type(type = "uuid-char")
    public UUID getParentContextId() {
        return parentContextId;
    }
 
    public void setParentContextId(UUID parentContextId) {
        this.parentContextId = parentContextId;
    }
 
    @Column
    @Type(type = "yes_no")
    public boolean isHidden() {
        return hidden;
    }
 
    public void setHidden(boolean hidden) {
        this.hidden = hidden;
    }
 
}

Dynamic insert and update means hibernate will check and make a query with the changes only. This is handy for queries that grow too big (like multiple text columns).

@DynamicInsert
@DynamicUpdate

Now we could use a DAO interface

LoginDAO.java

package be.mentoringsystems.merke.persistence;
 
import be.mentoringsystems.merke.model.QueryParams;
import be.mentoringsystems.merke.model.db.Login;
import java.util.List;
import java.util.UUID;
 
/**
 *
 * @author anthonyarents
 */
public interface LoginDAO {
 
    void save(Login obj);
 
    Login getById(UUID id);
 
    Login getByUsername(String username);
 
    List<Login> getAll(QueryParams queryParams);
 
    Long getCount(QueryParams queryParams);
}

ContextDAOImpl.java

package de.jcpis.analysestats.persistence.hibernate;
 
import de.jcpis.analysestats.helper.ConversionHelper;
import de.jcpis.analysestats.model.QueryParams;
import de.jcpis.analysestats.model.Sorting;
import de.jcpis.analysestats.model.db.Context;
import de.jcpis.analysestats.persistence.ContextDAO;
import java.util.ArrayList;
import java.util.List;
import javax.persistence.TypedQuery;
import javax.persistence.criteria.CriteriaBuilder;
import javax.persistence.criteria.CriteriaQuery;
import javax.persistence.criteria.Order;
import javax.persistence.criteria.Root;
import org.apache.commons.lang3.StringUtils;
import org.hibernate.Hibernate;
import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Repository;
 
/**
 *
 * @author anthonyarents
 */
@Repository
public class ContextDAOImpl implements ContextDAO {
 
    @Autowired
    private SessionFactory sessionFactory;
 
    @Override
    public void save(final Context obj) {
        sessionFactory.getCurrentSession().saveOrUpdate(obj);
    }
 
    @Override
    public void delete(final Context obj) {
        sessionFactory.getCurrentSession().delete(obj);
    }
 
    @Override
    public Context getById(final Integer id) {
        return sessionFactory.getCurrentSession().get(Context.class, id);
    }
 
    private void initializeDependencies(final List<Context> list) {
        for (Context obj : list) {
            initializeDependencies(obj);
        }
    }
 
    private void initializeDependencies(final Context obj) {
        if (obj != null) {
            Hibernate.initialize(obj.getServer());
        }
    }
 
    private void addFilters(final CriteriaBuilder builder, final Root<Context> root, final CriteriaQuery<?> criteriaQuery, final QueryParams queryParams) {
        final String name = ConversionHelper.toString(queryParams.getFilterValue("name"));
 
        if (!StringUtils.isEmpty(name)) {
            criteriaQuery.where(builder.like(root.<String>get("name"), name + "%"));
        }
    }
 
    private void addSorting(final CriteriaBuilder builder, final Root<Context> root, final CriteriaQuery<?> criteriaQuery, final QueryParams queryParams) {
        if (queryParams.getSort().getSortings().isEmpty()) {
            criteriaQuery.orderBy(builder.asc(root.get("name")));
        } else {
            final List<Order> orderList = new ArrayList<Order>();
            for (Sorting s : queryParams.getSort().getSortings()) {
                if ("ASC".equals(s.getDirection())) {
                    orderList.add(builder.asc(root.get(s.getProperty())));
                } else {
                    orderList.add(builder.desc(root.get(s.getProperty())));
                }
            }
            criteriaQuery.orderBy(orderList);
        }
    }
 
    @Override
    public List<Context> getAll(final QueryParams queryParams) {
        final Session session = sessionFactory.getCurrentSession();
        session.enableFilter("deletedObjectsFilter");
 
        final CriteriaBuilder builder = session.getCriteriaBuilder();
        final CriteriaQuery<Context> criteriaQuery = builder.createQuery(Context.class);
        final Root<Context> root = criteriaQuery.from(Context.class);
        criteriaQuery.select(root);
 
        addFilters(builder, root, criteriaQuery, queryParams);
        addSorting(builder, root, criteriaQuery, queryParams);
 
        final TypedQuery<Context> typedQuery = session.createQuery(criteriaQuery);
        typedQuery.setFirstResult(queryParams.getStart());
        if (queryParams.isLimitted()) {
            typedQuery.setMaxResults(queryParams.getLimit());
        }
 
        return typedQuery.getResultList();
    }
 
    @Override
    public Long getCount(final QueryParams queryParams) {
        final Session session = sessionFactory.getCurrentSession();
        session.enableFilter("deletedObjectsFilter");
 
        final CriteriaBuilder builder = session.getCriteriaBuilder();
        final CriteriaQuery<Long> criteriaQuery = builder.createQuery(Long.class);
        final Root<Context> root = criteriaQuery.from(Context.class);
        criteriaQuery.select(builder.count(root));
 
        addFilters(builder, root, criteriaQuery, queryParams);
 
        final TypedQuery<Long> typedQuery = session.createQuery(criteriaQuery);
        return typedQuery.getSingleResult();
    }
 
}