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
• Spring (latest → 4.3.9.RELEASE)
• Spring Security (latest → 4.2.3.RELEASE)
• Hibernate (latest → 5.2.10.Final)
• Javamelody (latest, developer tool, used for statistics)
• ExtJS 6
• Tomcat 7 or 8 (DOWNLOAD NEWEST FROM THEIR WEBSITE! required for java config, earlier versions supplied with netbeans are bad)
• Use Java 7 for compiling, I recommend Java 8 for running tomcat (no permgen errors) .

Code examples were taken from Merke or BoardPortal. This documentation is still a work in progress.

A website which allows you to keep a list of dependencies to watch :
https://www.artifact-listener.org/

Spring Blog 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.

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.

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.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

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 :

<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>
 
    <profiles>
  <profile>
    <id>java8-doclint-disabled</id>
    <activation>
      <jdk>[1.8,)</jdk>
    </activation>
    <properties>
      <javadoc.opts>-Xdoclint:none</javadoc.opts>
    </properties>
  </profile>
</profiles>
 
    <properties>
        <javax.servletapi>3.0.1</javax.servletapi>
        <javax.servletjspapi>2.2.1</javax.servletjspapi>
 
        <spring.version>4.3.8.RELEASE</spring.version>
        <springsecurity.version>4.2.2.RELEASE</springsecurity.version>
        <mysql.version>5.1.41</mysql.version>
        <dbcp.version>2.1.1</dbcp.version>
        <hibernate.version>5.2.10.Final</hibernate.version>
        <jackson.version>2.8.8</jackson.version>
        <apache.taglibs.version>1.2.5</apache.taglibs.version>
        <log4j.version>2.8.2</log4j.version>
        <commons.lang.version>3.5</commons.lang.version>
        <commons.io.version>2.5</commons.io.version>
        <commons.beanutils.version>1.9.3</commons.beanutils.version>
        <javax.mail.version>1.5.6</javax.mail.version>
        <apache.poi.version>3.16</apache.poi.version>
        <javamelody.version>1.67.0</javamelody.version>
        <findbugs.helper.version>3.0.2</findbugs.helper.version>
 
        <maven.compiler.source>1.7</maven.compiler.source>
        <maven.compiler.target>1.7</maven.compiler.target>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
 
        <report.plugin.maven.inforeports>2.9</report.plugin.maven.inforeports>
        <report.plugin.maven.jxr>2.5</report.plugin.maven.jxr>
        <report.plugin.maven.javadoc>2.10.4</report.plugin.maven.javadoc>
        <report.plugin.maven.checkstyle>2.17</report.plugin.maven.checkstyle>
        <report.plugin.maven.pmd>3.7</report.plugin.maven.pmd>
        <report.plugin.maven.surefire>2.20</report.plugin.maven.surefire>
        <report.plugin.codehaus.findbugs>3.0.4</report.plugin.codehaus.findbugs>
        <report.plugin.codehaus.taglist>2.4</report.plugin.codehaus.taglist>
        <report.plugin.codehaus.versions>2.3</report.plugin.codehaus.versions>
 
        <build.plugin.maven.site>3.6</build.plugin.maven.site>
        <build.plugin.maven.compiler>3.6.1</build.plugin.maven.compiler>
        <build.plugin.maven.deploy>2.8.2</build.plugin.maven.deploy>
        <build.plugin.maven.clean>3.0.0</build.plugin.maven.clean>
        <build.plugin.maven.install>2.5.2</build.plugin.maven.install>
        <build.plugin.maven.dependency>3.0.0</build.plugin.maven.dependency>
        <build.plugin.maven.war>3.1.0</build.plugin.maven.war>
        <build.plugin.maven.resources>3.0.2</build.plugin.maven.resources>
        <build.plugin.maven.surefire>2.20</build.plugin.maven.surefire>
        <build.plugin.tomcat.maven.tomcat7>2.2</build.plugin.tomcat.maven.tomcat7>
    </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>org.apache.taglibs</groupId>
            <artifactId>taglibs-standard-spec</artifactId>
            <version>${apache.taglibs.version}</version>
        </dependency>
        <dependency>
            <groupId>org.apache.taglibs</groupId>
            <artifactId>taglibs-standard-impl</artifactId>
            <version>${apache.taglibs.version}</version>
        </dependency>
        <!-- Spring dependencies -->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-core</artifactId>
            <version>${spring.version}</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-web</artifactId>
            <version>${spring.version}</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-webmvc</artifactId>
            <version>${spring.version}</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-orm</artifactId>
            <version>${spring.version}</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context-support</artifactId>
            <version>${spring.version}</version>
        </dependency>
        <!-- Spring Security -->
        <dependency>
            <groupId>org.springframework.security</groupId>
            <artifactId>spring-security-web</artifactId>
            <version>${springsecurity.version}</version>
        </dependency>
        <dependency>
            <groupId>org.springframework.security</groupId>
            <artifactId>spring-security-config</artifactId>
            <version>${springsecurity.version}</version>
        </dependency>
        <dependency>
            <groupId>org.springframework.security</groupId>
            <artifactId>spring-security-taglibs</artifactId>
            <version>${springsecurity.version}</version>
        </dependency>
        <!-- DBCP (database) -->
        <dependency>
            <groupId>org.apache.commons</groupId>
            <artifactId>commons-dbcp2</artifactId>
            <version>${dbcp.version}</version>
        </dependency>
        <dependency>
            <groupId>org.apache.commons</groupId>
            <artifactId>commons-lang3</artifactId>
            <version>${commons.lang.version}</version>
        </dependency>
        <!-- Mysql -->
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>${mysql.version}</version>
        </dependency>
        <!-- Hibernate -->
        <dependency>
            <groupId>org.hibernate</groupId>
            <artifactId>hibernate-core</artifactId>
            <version>${hibernate.version}</version>
        </dependency>
        <dependency>
            <groupId>com.fasterxml.jackson.core</groupId>
            <artifactId>jackson-core</artifactId>
            <version>${jackson.version}</version>
        </dependency>
        <dependency>
            <groupId>com.fasterxml.jackson.core</groupId>
            <artifactId>jackson-databind</artifactId>
            <version>${jackson.version}</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}</version>
        </dependency>
        <dependency>
            <groupId>com.fasterxml.jackson.dataformat</groupId>
            <artifactId>jackson-dataformat-xml</artifactId>
            <version>${jackson.version}</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}</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}</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}</version>
        </dependency>
        <dependency>
            <groupId>org.apache.logging.log4j</groupId>
            <artifactId>log4j-api</artifactId>
            <version>${log4j.version}</version>
        </dependency>
        <dependency>
            <groupId>org.apache.logging.log4j</groupId>
            <artifactId>log4j-web</artifactId>
            <version>${log4j.version}</version>
        </dependency>
        <dependency>
            <groupId>org.apache.logging.log4j</groupId>
            <artifactId>log4j-slf4j-impl</artifactId>
            <version>${log4j.version}</version>
        </dependency>
        <dependency>
            <groupId>commons-io</groupId>
            <artifactId>commons-io</artifactId>
            <version>${commons.io.version}</version>
        </dependency>
        <dependency>
            <groupId>commons-beanutils</groupId>
            <artifactId>commons-beanutils</artifactId>
            <version>${commons.beanutils.version}</version>
        </dependency>
        <dependency>
            <groupId>com.sun.mail</groupId>
            <artifactId>javax.mail</artifactId>
            <version>${javax.mail.version}</version>
        </dependency>
        <dependency>
            <groupId>org.apache.poi</groupId>
            <artifactId>poi</artifactId>
            <version>${apache.poi.version}</version>
        </dependency>
        <dependency>
            <groupId>org.apache.poi</groupId>
            <artifactId>poi-ooxml</artifactId>
            <version>${apache.poi.version}</version>
        </dependency>
        <dependency>
            <groupId>net.bull.javamelody</groupId>
            <artifactId>javamelody-core</artifactId>
            <version>${javamelody.version}</version>
        </dependency>
        <dependency>
            <groupId>com.google.code.findbugs</groupId>
            <artifactId>jsr305</artifactId>
            <version>${findbugs.helper.version}</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>
                    <additionalparam>${javadoc.opts}</additionalparam>
                </configuration>
        </executions>
            </plugin>
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-checkstyle-plugin</artifactId>
                <version>${report.plugin.maven.checkstyle}</version>
                <configuration>
                    <checkstyleRules>
                        <module name="LineLength">
                            <property name="max" value="120"/>
                        </module>
                    </checkstyleRules>
                </configuration>
                <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>
                </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>
        <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>
                <artifactId>maven-deploy-plugin</artifactId>
                <version>${build.plugin.maven.deploy}</version>
            </plugin>
            <plugin>
                <artifactId>maven-clean-plugin</artifactId>
                <version>${build.plugin.maven.clean}</version>
            </plugin>
            <plugin>
                <artifactId>maven-install-plugin</artifactId>
                <version>${build.plugin.maven.install}</version>
            </plugin>
            <plugin>
                <groupId>org.apache.tomcat.maven</groupId>
                <artifactId>tomcat7-maven-plugin</artifactId>
                <version>${build.plugin.tomcat.maven.tomcat7}</version>
                <configuration>
                    <mode>both</mode>
                </configuration>
            </plugin>
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-dependency-plugin</artifactId>
                <version>${build.plugin.maven.dependency}</version>
            </plugin>
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-war-plugin</artifactId>
                <version>${build.plugin.maven.war}</version>
                <configuration>
                    <useCache>true</useCache>
                </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,
the parent pom ensures all projects use UTF-8 encoding for files & sets some maven plugins.

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.14</version>
        </dependency>

Hibernate search (for textsearching purposes / index)

<dependency>
   <groupId>org.hibernate</groupId>
   <artifactId>hibernate-search-orm</artifactId>
   <version>5.7.0.Final</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
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

<?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"/>
    <Parameter name="database_catalog" value="applicationname"/>
 
    <Parameter name="searchindexPath" value="/var/mentoringsystems/applicationname/index"/>
 
    <Parameter name="uploadPath" value="/var/mentoringsystems/applicationname"/>
</Context>

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

<?xml version="1.0" encoding="UTF-8"?>
<web-app version="3.0" xmlns="http://java.sun.com/xml/ns/javaee" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://java.sun.com/xml/ns/javaee http://java.sun.com/xml/ns/javaee/web-app_3_0.xsd">
    <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

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

package be.mentoringsystems.boardportal.config;
 
import java.nio.charset.Charset;
import java.text.SimpleDateFormat;
import java.util.List;
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.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.ResourceHandlerRegistry;
import org.springframework.web.servlet.config.annotation.ViewControllerRegistry;
import org.springframework.web.servlet.config.annotation.ViewResolverRegistry;
import org.springframework.web.servlet.config.annotation.WebMvcConfigurerAdapter;
 
/**
 *
 * @author anthonyarents
 */
@Configuration
@EnableWebMvc
public class MvcConfiguration extends WebMvcConfigurerAdapter {
 
    @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.useJaf(false);
        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);
 
        Jackson2ObjectMapperBuilder builder = new Jackson2ObjectMapperBuilder();
        builder.indentOutput(true);
        builder.defaultViewInclusion(true);
        builder.modules(hibernate5Module);
        builder.dateFormat(new SimpleDateFormat("yyyy-MM-dd HH:mm")).timeZone("CET");
        converters.add(new MappingJackson2HttpMessageConverter(builder.build()));
 
        final StringHttpMessageConverter stringMessageConverter = new StringHttpMessageConverter(Charset.forName("UTF-8"));
        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/image/**").addResourceLocations("/static/image/").setCachePeriod(2678400);
        // development boardportal
        registry.addResourceHandler("/static/BoardPortal/**").addResourceLocations("/static/BoardPortal/").setCachePeriod(604800);
        // production boardportal
 
        //registry.addResourceHandler("/static/BoardPortal/**").addResourceLocations("/static/BoardPortal/build/production/BoardPortal/").setCachePeriod(604800);
        //registry.addResourceHandler("/BoardPortal/**").addResourceLocations("/static/BoardPortal/build/production/BoardPortal/").setCachePeriod(604800);
        //registry.addResourceHandler("/production/BoardPortal/**").addResourceLocations("/static/BoardPortal/build/production/BoardPortal/").setCachePeriod(604800);
        super.addResourceHandlers(registry);
    }
 
    @Override
    public void configureViewResolvers(final ViewResolverRegistry registry) {
        registry.jsp("/WEB-INF/jsp/", ".jsp");
    }
 
    @Override
    public void addViewControllers(final ViewControllerRegistry registry) {
        registry.addViewController("/login").setViewName("login");
        registry.setOrder(Ordered.HIGHEST_PRECEDENCE);
        // development boardportal
        registry.addRedirectViewController("/", "/static/BoardPortal/");
    }
 
    @Bean(name = "multipartResolver")
    public StandardServletMultipartResolver multipartResolver() {
        return new StandardServletMultipartResolver();
    }
 
    @Override
    public void addCorsMappings(CorsRegistry registry) {
        registry.addMapping("/**");
    }
 
}

package be.mentoringsystems.boardportal.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;
 
    @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.jdbc.Driver");
        bds.setMaxIdle(17);
        bds.setMaxTotal(20);
        bds.setMaxWaitMillis(10000);
        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.boardportal.model.db"});
        sessionFactory.setPackagesToScan(new String[]{"be.mentoringsystems.boardportal.model.db"});
        sessionFactory.setHibernateProperties(getHibernateProperties());
        return sessionFactory;
    }
 
    @Bean
    @Autowired
    public HibernateTransactionManager transactionManager(final SessionFactory s) {
        HibernateTransactionManager txManager = new HibernateTransactionManager();
        txManager.setSessionFactory(s);
        return txManager;
    }
}

package be.mentoringsystems.boardportal.config;
 
import be.mentoringsystems.boardportal.service.LoginService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.security.authentication.encoding.Md5PasswordEncoder;
import org.springframework.security.config.annotation.authentication.builders.AuthenticationManagerBuilder;
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;
 
 
/**
 *
 * @author anthonyarents
 */
@EnableWebSecurity
public class SecurityConfiguration extends WebSecurityConfigurerAdapter{
 
    @Autowired
    private LoginService loginService;
 
    @Override
    public void configure(final WebSecurity web) throws Exception {
        web.ignoring().antMatchers("/static/**", "/app/**");
    }
 
    @Override
    protected void configure(final HttpSecurity http) throws Exception {
        // temporary
        http.csrf().disable();
        http.headers().frameOptions().sameOrigin();
        http.userDetailsService(loginService);
        http
            .formLogin()
                .loginPage("/login").defaultSuccessUrl("/", true).failureUrl("/login?error").permitAll() //login page, redirect tologinrequired page if there was one, permitall is necessary
                .and()
                .logout().logoutUrl("/logout").permitAll() // logout page, permitall is necessary
                .and()
           .authorizeRequests() // request matching with ant
                .antMatchers("/login/**").permitAll() // allows for login to have more get requests (localization)
                .antMatchers("/register").permitAll()
                .antMatchers("/event/**").permitAll()
                .anyRequest().authenticated(); // all remaining requests need login
    }
 
    @Override
    protected void configure(AuthenticationManagerBuilder auth) throws Exception {
        Md5PasswordEncoder passwordEncoder = new Md5PasswordEncoder();
        auth.userDetailsService(loginService).passwordEncoder(passwordEncoder);
    }
 
}

removes web.xml config: the servlet code

package be.mentoringsystems.boardportal.config.initializer;
 
import be.mentoringsystems.boardportal.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(ServletRegistration.Dynamic registration) {
        MultipartConfigElement multipartConfigElement = new MultipartConfigElement("/tmp", parseSize("50MB"), parseSize("70MB"), 0);
        registration.setMultipartConfig(multipartConfigElement);
    }
 
    // convience to make this config a bit more readable...
	private long parseSize(String size) {
		size = size.toUpperCase();
		if (size.endsWith("KB")) {
			return Long.valueOf(size.substring(0, size.length() - 2)) * 1024;
		}
		if (size.endsWith("MB")) {
			return Long.valueOf(size.substring(0, size.length() - 2)) * 1024 * 1024;
		}
		return Long.valueOf(size);
	}
 
}

removes web.xml config: filterchain

package be.mentoringsystems.boardportal.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

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

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).

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

package be.mentoringsystems.merke.model;
 
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>();
 
    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;
    }
 
    @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 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;
    }
}

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(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();
        }
    }
}

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

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;
    }
}

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

package be.mentoringsystems.merke.helper;
 
import java.io.Serializable;
import java.util.UUID;
import org.hibernate.HibernateException;
import org.hibernate.engine.SessionImplementor;
 
/**
 *
 * @author anthonyarents
 */
public class UUIDTypeGenerator extends org.hibernate.id.GUIDGenerator {
 
    public UUIDTypeGenerator() {
        super();
    }
 
    @Override
    public Serializable generate(SessionImplementor session, Object obj) throws HibernateException {
        String result = (String) super.generate(session, obj);
        return UUID.fromString(result);
    }
}

package be.mentoringsystems.merke.helper;
 
import java.util.ArrayList;
import java.util.Date;
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 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 Date toDate(final Object obj) {
        if (obj == null) {
            return null;
        }
        if (obj instanceof Date) {
            return (Date) obj;
        }
        return null;
    }
 
    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;
    }
}

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 class 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>”

package be.mentoringsystems.merke.model.db;
 
import be.mentoringsystems.merke.model.dto.View;
import com.fasterxml.jackson.annotation.JsonIgnore;
import com.fasterxml.jackson.annotation.JsonView;
import java.io.Serializable;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Date;
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.Temporal;
import javax.persistence.TemporalType;
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 Date createdOn = new Date();
    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
    @Temporal(TemporalType.TIMESTAMP)
    public Date getCreatedOn() {
        return (createdOn == null ? null : new Date(createdOn.getTime()));
    }
 
    public void setCreatedOn(Date createdOn) {
        this.createdOn = (createdOn == null ? null : new Date(createdOn.getTime()));
    }
 
    @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

@GenericGenerator(
    name = "uuid",
    strategy = "be.mentoringsystems.helper.UUIDTypeGenerator"
)
@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;

Now we could use a DAO interface

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

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

Superclass

package be.mentoringsystems.merke.persistence.hibernate;
 
import be.mentoringsystems.merke.model.Filter;
import be.mentoringsystems.merke.model.QueryParams;
import be.mentoringsystems.merke.model.Sorting;
import java.util.List;
import org.hibernate.criterion.DetachedCriteria;
import org.hibernate.criterion.Order;
import org.hibernate.criterion.Restrictions;
import org.springframework.orm.hibernate5.support.HibernateDaoSupport;
 
/**
 *
 * @author anthonyarents
 */
public class HibernateDAO extends HibernateDaoSupport {
    private static final String SORT_DESC = "DESC";
 
    protected boolean addSorting(final DetachedCriteria criteria, final QueryParams queryParams) {
        if (queryParams.getSort() == null) {
            return false;
        } else {
            for (Sorting sorting : queryParams.getSort().getSortings()) {
                addOrder(criteria, sorting);
            }
            return true;
        }
    }
 
    protected void addOrder(final DetachedCriteria criteria, Sorting sorting) {
        criteria.addOrder(getOrder(sorting.getDirection(), sorting.getProperty()));
    }
 
    protected Order getOrder(final String dir, final String property) {
        if (SORT_DESC.equals(dir)) {
            return Order.desc(property);
        } else {
            return Order.asc(property);
        }
    }
 
    protected boolean addFilter(final DetachedCriteria criteria, final QueryParams queryParams) {
        if (queryParams.getFilter() == null) {
            return false;
        } else {
            for (Filter filter : queryParams.getFilter().getFilters()) {
                if (filter.getValue() == null) {
                    criteria.add(Restrictions.isNull(filter.getProperty()));
                } else {
                    criteria.add(Restrictions.eq(filter.getProperty(), filter.getValue()));
                }
            }
            return true;
        }
    }
 
    List<?> byCriteria(final DetachedCriteria criteria, final QueryParams queryParams) {
        return getHibernateTemplate().findByCriteria(criteria, queryParams.getStart(), queryParams.getLimit());
    }
 
    List<?> byCriteriaS(final DetachedCriteria criteria, final QueryParams queryParams) {
        addSorting(criteria, queryParams);
        return getHibernateTemplate().findByCriteria(criteria, queryParams.getStart(), queryParams.getLimit());
    }
 
    List<?> byCriteriaF(final DetachedCriteria criteria, final QueryParams queryParams) {
        addFilter(criteria, queryParams);
        return getHibernateTemplate().findByCriteria(criteria, queryParams.getStart(), queryParams.getLimit());
    }
 
    List<?> byCriteriaFS(final DetachedCriteria criteria, final QueryParams queryParams) {
        addFilter(criteria, queryParams);
        addSorting(criteria, queryParams);
        return getHibernateTemplate().findByCriteria(criteria, queryParams.getStart(), queryParams.getLimit());
    }
}

A Hibernate DAO implementation

package be.mentoringsystems.merke.persistence.hibernate;
 
import be.mentoringsystems.merke.helper.ConversionHelper;
import be.mentoringsystems.merke.model.QueryParams;
import be.mentoringsystems.merke.model.db.Login;
import be.mentoringsystems.merke.persistence.LoginDAO;
import java.util.List;
import java.util.UUID;
import org.apache.commons.lang3.StringUtils;
import org.hibernate.SessionFactory;
import org.hibernate.criterion.DetachedCriteria;
import org.hibernate.criterion.MatchMode;
import org.hibernate.criterion.Projections;
import org.hibernate.criterion.Restrictions;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Repository;
 
/**
 *
 * @author anthonyarents
 */
@Repository
@SuppressWarnings("unchecked")
public class LoginDAOImpl extends HibernateDAO implements LoginDAO {
 
    @Override
    public void save(final Login obj) {
        getHibernateTemplate().saveOrUpdate(obj);
    }
 
    @Override
    public Login getById(final UUID id) {
        final Login result = getHibernateTemplate().get(Login.class, id);
        return result;
    }
 
    @Override
    public Login getByUsername(final String username) {
        final DetachedCriteria criteria = DetachedCriteria.forClass(Login.class);
        criteria.add(Restrictions.eq("deleted", false));
        criteria.add(Restrictions.eq("username", username));
        List<Login> result = (List<Login>) getHibernateTemplate().findByCriteria(criteria);
        if(result.isEmpty()) {
            return null;
        } else {
            return result.get(0);
        }
    }
 
    private void addFilters(final DetachedCriteria criteria, final QueryParams queryParams) {
        final String search = ConversionHelper.toString(queryParams.getFilterValue("search"));
 
        if(!StringUtils.isEmpty(search)) {
            criteria.add(
                Restrictions.or(
                        Restrictions.ilike("firstname", search, MatchMode.ANYWHERE),
                        Restrictions.ilike("lastname", search, MatchMode.ANYWHERE),
                        Restrictions.ilike("username", search, MatchMode.ANYWHERE)
                ));
        }
    }
 
    @Override
    public List<Login> getAll(final QueryParams queryParams) {
        final DetachedCriteria criteria = DetachedCriteria.forClass(Login.class);
        criteria.add(Restrictions.eq("deleted", false));
 
        addFilters(criteria, queryParams);
        addSorting(criteria, queryParams);
 
        return (List<Login>) getHibernateTemplate().findByCriteria(criteria, queryParams.getStart(), queryParams.getLimit());
    }
 
    @Override
    public Long getCount(final QueryParams queryParams) {
        final DetachedCriteria criteria = DetachedCriteria.forClass(Login.class);
        criteria.add(Restrictions.eq("deleted", false));
 
        addFilters(criteria, queryParams);
 
        criteria.setProjection(Projections.rowCount());
        List<Long> result = (List<Long>) getHibernateTemplate().findByCriteria(criteria);
        return result.get(0);
    }
 
    @Autowired
    public void init(SessionFactory factory) {
        setSessionFactory(factory);
    }
 
}

package be.mentoringsystems.merke.persistence.hibernate;
 
import be.mentoringsystems.merke.helper.ConversionHelper;
import be.mentoringsystems.merke.model.QueryParams;
import be.mentoringsystems.merke.model.db.Vendor;
import be.mentoringsystems.merke.model.db.Vendorstall;
import be.mentoringsystems.merke.persistence.VendorDAO;
import java.util.List;
import java.util.UUID;
import org.apache.commons.lang3.StringUtils;
import org.hibernate.SessionFactory;
import org.hibernate.criterion.DetachedCriteria;
import org.hibernate.criterion.MatchMode;
import org.hibernate.criterion.Projections;
import org.hibernate.criterion.Restrictions;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.orm.hibernate5.HibernateTemplate;
import org.springframework.stereotype.Repository;
 
/**
 *
 * @author anthonyarents
 */
@Repository
@SuppressWarnings("unchecked")
public class VendorDAOImpl extends HibernateDAO implements VendorDAO {
 
    private void initializeDependencies(final HibernateTemplate template, final List<Vendor> list) {
        for(Vendor obj : list) {
            initializeDependencies(template, obj);
        }
    }
 
    private void initializeDependencies(final HibernateTemplate template, final Vendor obj) {
        template.initialize(obj.getVendorstalls());
        for(Vendorstall vendorstall : obj.getVendorstalls()) {
            template.initialize(vendorstall.getCertificates());
        }
        template.initialize(obj.getRemarks());
    }
 
    @Autowired
    public void init(SessionFactory factory) {
        setSessionFactory(factory);
    }
 
    @Override
    public void save(Vendor obj) {
        getHibernateTemplate().saveOrUpdate(obj);
    }
 
    @Override
    public Vendor getById(UUID id) {
        final HibernateTemplate template = getHibernateTemplate();
        final Vendor result = template.get(Vendor.class, id);
        initializeDependencies(template, result);
        return result;
    }
 
    private void addFilters(DetachedCriteria criteria, QueryParams queryParams) {
        final List<Integer> years = ConversionHelper.toIntegerList(queryParams.getFilterValue("years"));
        final List<UUID> venueIds = ConversionHelper.toUUIDList(queryParams.getFilterValue("venueIds"));
        final List<UUID> categories = ConversionHelper.toUUIDList(queryParams.getFilterValue("categoryIds"));
        final List<String> remarktypes = ConversionHelper.toStringList(queryParams.getFilterValue("remarktypes"));
        final String search = ConversionHelper.toString(queryParams.getFilterValue("search"));
 
        boolean vendorstalljoin = false;
        if(!StringUtils.isEmpty(search)) {
            criteria.add(Restrictions.or(
                Restrictions.ilike("firstname", search, MatchMode.START), 
                Restrictions.ilike("lastname", search, MatchMode.START), 
                Restrictions.ilike("companyName", search, MatchMode.START)
            ));
        }
        if(!venueIds.isEmpty()) {
            if(!vendorstalljoin) {
                criteria.createAlias("vendorstalls", "vstall");
                vendorstalljoin = true;
            }
            criteria.createAlias("vstall.venues", "ven");
            criteria.add(Restrictions.in("ven.id", venueIds));
        }
        if(!categories.isEmpty()) {
            if(!vendorstalljoin) {
                criteria.createAlias("vendorstalls", "vstall");
                vendorstalljoin = true;
            }
            criteria.createAlias("vstall.categories", "cat");
            criteria.add(Restrictions.in("cat.id", categories));
        }
        if(!remarktypes.isEmpty()) {
            criteria.createAlias("remarks", "rem");
            criteria.add(Restrictions.in("rem.category", remarktypes));
        }
        if(!years.isEmpty()) {
            final StringBuilder inBuilder = new StringBuilder("YEAR(createdOn) IN (").append(StringUtils.join(years, ",")).append(")");
            criteria.add(Restrictions.sqlRestriction(inBuilder.toString()));
        }
    }
 
    @Override
    public List<Vendor> getAll(QueryParams queryParams) {
        final HibernateTemplate template = getHibernateTemplate();
        final DetachedCriteria criteria = DetachedCriteria.forClass(Vendor.class);
        criteria.add(Restrictions.eq("deleted", false));
 
        addFilters(criteria, queryParams);
        addSorting(criteria, queryParams);
 
        final List<Vendor> result = (List<Vendor>) template.findByCriteria(criteria, queryParams.getStart(), queryParams.getLimit());
        initializeDependencies(template, result);
        return result;
    }
 
    @Override
    public Long getCount(QueryParams queryParams) {
        final DetachedCriteria criteria = DetachedCriteria.forClass(Vendor.class);
        criteria.add(Restrictions.eq("deleted", false));
 
        addFilters(criteria, queryParams);
 
        criteria.setProjection(Projections.rowCount());
        final List<Long> result = (List<Long>) getHibernateTemplate().findByCriteria(criteria);
        return result.get(0);
    }
 
}

Advanced hibernate criteria queries exist, If you need examples contact me .

Of note : extends UserDetailsService (allows for custom spring security login)

package be.mentoringsystems.merke.service;
 
import be.mentoringsystems.merke.model.QueryParams;
import be.mentoringsystems.merke.model.db.Login;
import be.mentoringsystems.merke.model.dto.LoginDTO;
import be.mentoringsystems.merke.model.dto.PagedListDTO;
import java.util.List;
import java.util.UUID;
import org.springframework.security.core.userdetails.UserDetailsService;
 
/**
 *
 * @author anthonyarents
 */
public interface LoginService extends UserDetailsService {
    void save(final Login obj);
    Login save(final LoginDTO dto);
    void delete(final Login obj);
    void delete(final UUID id);
    Login getById(final UUID id);
    Login getByUsername(final String login);
    List<Login> getAll(final QueryParams queryParams);
    Long getCount(final QueryParams queryParams);
    PagedListDTO getAllDTO(final QueryParams queryParams);
    Login getCurrentLogin();
    Login getSourceLogin();
}

package be.mentoringsystems.merke.service;
 
import be.mentoringsystems.merke.model.QueryParams;
import be.mentoringsystems.merke.model.db.Vendor;
import be.mentoringsystems.merke.model.dto.PagedListDTO;
import be.mentoringsystems.merke.model.dto.VendorDTO;
import java.util.List;
import java.util.UUID;
 
/**
 *
 * @author anthonyarents
 */
public interface VendorService {
    void save(final Vendor obj);
    Vendor save(final VendorDTO dto);
    void delete(final Vendor obj);
    void delete(final UUID id);
    Vendor getById(final UUID id);
    List<Vendor> getAll(final QueryParams queryParams);
    Long getCount(final QueryParams queryParams);
    PagedListDTO getAllDTO(final QueryParams queryParams);
}

package be.mentoringsystems.merke.service.impl;
 
import be.mentoringsystems.merke.helper.DTOHelper;
import be.mentoringsystems.merke.model.QueryParams;
import be.mentoringsystems.merke.model.db.Login;
import be.mentoringsystems.merke.model.dto.LoginDTO;
import be.mentoringsystems.merke.model.dto.PagedListDTO;
import be.mentoringsystems.merke.persistence.LoginDAO;
import be.mentoringsystems.merke.service.LoginService;
import java.io.UnsupportedEncodingException;
import java.util.ArrayList;
import java.util.List;
import java.util.UUID;
import org.apache.logging.log4j.LogManager;
import org.apache.logging.log4j.Logger;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.security.core.Authentication;
import org.springframework.security.core.GrantedAuthority;
import org.springframework.security.core.authority.SimpleGrantedAuthority;
import org.springframework.security.core.context.SecurityContextHolder;
import org.springframework.security.core.userdetails.UserDetails;
import org.springframework.security.core.userdetails.UsernameNotFoundException;
import org.springframework.security.web.authentication.switchuser.SwitchUserGrantedAuthority;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Propagation;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.util.DigestUtils;
import org.springframework.util.StringUtils;
 
/**
 *
 * @author anthonyarents
 */
@Service
@Transactional(propagation = Propagation.SUPPORTS)
public class LoginServiceImpl implements LoginService {
 
    @Autowired
    private transient LoginDAO loginDAO;
    private static final Logger LOGGER = LogManager.getLogger(LoginServiceImpl.class);
 
    @Override
    @Transactional(propagation = Propagation.REQUIRED)
    public void save(final Login login) {
        loginDAO.save(login);
    }
 
    @Override
    @Transactional(propagation = Propagation.REQUIRED)
    public Login save(final LoginDTO dto) {
        Login obj;
        if(dto.getId() == null) {
            obj = new Login();
            LOGGER.info("Creating a new Login");
        } else {
            obj = getById(dto.getId());
            LOGGER.info("Updating existing Login({})", dto.getId());
        }
 
        String dtoPassword = dto.getPassword();
        dto.setPassword(null);
 
        DTOHelper.copyNonNull(dto, obj);
 
        if(StringUtils.hasText(dtoPassword)) obj.setPassword(encryptPassword(dtoPassword));
 
        save(obj);
        LOGGER.info("Login({}) saved", obj.getId());
        return obj;
    }
 
    @Override
    @Transactional(propagation = Propagation.REQUIRED)
    public void delete(final Login login) {
        login.setDeleted(true);
        save(login);
        LOGGER.info("Login({}) deleted", login.getId());
    }
 
    @Override
    @Transactional(propagation = Propagation.REQUIRED)
    public void delete(final UUID id) {
        final Login login = getById(id);
        delete(login);
    }
 
    @Override
    @Transactional(readOnly = true)
    public Login getById(final UUID id) {
        return loginDAO.getById(id);
    }
 
    @Override
    @Transactional(readOnly = true)
    public Login getByUsername(final String username) {
        return loginDAO.getByUsername(username);
    }
 
    @Override
    @Transactional(readOnly = true)
    public List<Login> getAll(final QueryParams queryParams) {
        return loginDAO.getAll(queryParams);
    }
 
    @Override
    @Transactional(readOnly = true)
    public Long getCount(final QueryParams queryParams) {
        return loginDAO.getCount(queryParams);
    }
 
    @Override
    @Transactional(readOnly = true)
    public PagedListDTO getAllDTO(final QueryParams queryParams) {
        final PagedListDTO pagedListDTO = new PagedListDTO();
        pagedListDTO.setData(getAll(queryParams));
        pagedListDTO.setTotal(getCount(queryParams));
        return pagedListDTO;
    }
 
    public String encryptPassword(final String password) {
        String result = password;
        try {
            result = DigestUtils.md5DigestAsHex(password.getBytes("UTF-8"));
        } catch (UnsupportedEncodingException ex) {
            LOGGER.error(ex.getMessage(), ex);
        }
        return result;
    }
 
    @Override
    @Transactional(readOnly = true)
    public UserDetails loadUserByUsername(final String loginName) throws UsernameNotFoundException {
        final Login login = getByUsername(loginName);
 
        if(login == null) {
            throw new UsernameNotFoundException(loginName);
        } else {
            login.setAuthorities(getAuthorities(login));
            return login;
        }
    }
 
    public List<GrantedAuthority> getAuthorities(final Login login) {
        final List<GrantedAuthority> authorities = new ArrayList<>();
        if(login.getGroup() == 1) {
            authorities.add(new SimpleGrantedAuthority("ROLE_ADMIN"));
        }
        if(login.getGroup() == 3) {
            authorities.add(new SimpleGrantedAuthority("ROLE_FIREMAN"));
        }
        authorities.add(new SimpleGrantedAuthority("ROLE_USER"));
        return authorities;
    }
 
    @Override
    public Login getCurrentLogin() {
        Object principal = SecurityContextHolder.getContext().getAuthentication().getPrincipal();
        if(principal instanceof Login) {
            return (Login) principal;
        }
        return null;
    }
 
    @Override
    public Login getSourceLogin() {
        final Login current = getCurrentLogin();
        Login original = null;
 
        for (GrantedAuthority auth : current.getAuthorities()) {
            if (auth instanceof SwitchUserGrantedAuthority) {
                Authentication authSource = ((SwitchUserGrantedAuthority) auth).getSource();
                if(authSource instanceof Login) original = (Login) authSource;
            }
        }
 
        return original;
    }
 
}

package be.mentoringsystems.merke.service.impl;
 
import be.mentoringsystems.merke.helper.DTOHelper;
import be.mentoringsystems.merke.model.QueryParams;
import be.mentoringsystems.merke.model.db.Vendor;
import be.mentoringsystems.merke.model.dto.PagedListDTO;
import be.mentoringsystems.merke.model.dto.VendorDTO;
import be.mentoringsystems.merke.persistence.VendorDAO;
import be.mentoringsystems.merke.service.VendorService;
import java.util.List;
import java.util.UUID;
import org.apache.logging.log4j.LogManager;
import org.apache.logging.log4j.Logger;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Propagation;
import org.springframework.transaction.annotation.Transactional;
 
/**
 *
 * @author anthonyarents
 */
@Service
@Transactional(propagation = Propagation.SUPPORTS)
public class VendorServiceImpl implements VendorService {
    @Autowired
    private transient VendorDAO vendorDAO;
    private static final Logger LOGGER = LogManager.getLogger(VendorServiceImpl.class);
 
    @Override
    @Transactional(propagation = Propagation.REQUIRED)
    public void save(Vendor obj) {
        vendorDAO.save(obj);
    }
 
    @Override
    @Transactional(propagation = Propagation.REQUIRED)
    public Vendor save(VendorDTO dto) {
        Vendor obj;
        if(dto.getId() == null) {
            obj = new Vendor();
            LOGGER.info("Creating a new Vendor");
        } else {
            obj = getById(dto.getId());
            LOGGER.info("Updating existing Vendor({})", dto.getId());
        }
 
        DTOHelper.copyNonNull(dto, obj);
 
        save(obj);
        LOGGER.info("Vendor({}) saved", obj.getId());
        return obj;
    }
 
    @Override
    @Transactional(propagation = Propagation.REQUIRED)
    public void delete(Vendor obj) {
        obj.setDeleted(true);
        save(obj);
        LOGGER.info("Vendor({}) deleted", obj.getId());
    }
 
    @Override
    @Transactional(propagation = Propagation.REQUIRED)
    public void delete(UUID id) {
        final Vendor obj = getById(id);
        delete(obj);
    }
 
    @Override
    @Transactional(readOnly = true)
    public Vendor getById(UUID id) {
        return vendorDAO.getById(id);
    }
 
    @Override
    @Transactional(readOnly = true)
    public List<Vendor> getAll(final QueryParams queryParams) {
        return vendorDAO.getAll(queryParams);
    }
 
    @Override
    @Transactional(readOnly = true)
    public Long getCount(final QueryParams queryParams) {
        return vendorDAO.getCount(queryParams);
    }
 
    @Override
    @Transactional(readOnly = true)
    public PagedListDTO getAllDTO(final QueryParams queryParams) {
        final PagedListDTO result = new PagedListDTO();
        result.setData(getAll(queryParams));
        result.setTotal(getCount(queryParams));
        return result;
    }
}

Jsonview values, notice we'll be using public as a default.

package be.mentoringsystems.merke.model.dto;
 
 
/**
 *
 * @author anthonyarents
 */
public class View {
    public interface Public {};
    public interface Vendor extends Public {};
    public interface Login extends Public {};
    public interface Venue extends Public {};
    public interface Certificate extends Public {};
}

We're using DTO objects to have more control of incoming data.

package be.mentoringsystems.merke.model.dto;
 
import java.util.UUID;
 
/**
 *
 * @author anthonyarents
 */
public class LoginDTO {
    private UUID id;
    private String firstname;
    private String lastname;
    private String email;
    private String password;
    private Integer group;
    private String username;
    private Boolean active;
 
    public Boolean getActive() {
        return active;
    }
 
    public void setActive(Boolean active) {
        this.active = active;
    }
 
    public UUID getId() {
        return id;
    }
 
    public void setId(final UUID id) {
        this.id = id;
    }
 
    public String getEmail() {
        return email;
    }
 
    public void setEmail(final String email) {
        this.email = email;
    }
 
    public String getFirstname() {
        return firstname;
    }
 
    public void setFirstname(final String firstname) {
        this.firstname = firstname;
    }
 
    public Integer getGroup() {
        return group;
    }
 
    public void setGroup(Integer group) {
        this.group = group;
    }
 
    public String getLastname() {
        return lastname;
    }
 
    public void setLastname(final String lastname) {
        this.lastname = lastname;
    }
 
    public String getUsername() {
        return username;
    }
 
    public void setUsername(String username) {
        this.username = username;
    }
 
    public String getPassword() {
        return password;
    }
 
    public void setPassword(final String password) {
        this.password = password;
    }
}

package be.mentoringsystems.merke.model.dto;
 
import java.util.Date;
import java.util.UUID;
 
/**
 *
 * @author anthonyarents
 */
public class VendorDTO {
    private UUID id;
    private UUID parentid;
    private UUID loginId;
    private String title;
    private String title2;
    private String firstname;
    private String lastname;
    private String idnrNationalRegister;
    private String street;
    private String number;
    private String postalcode;
    private String city;
    private String companyName;
    private String companyNumber;
    private String bankaccount;
    private String telephonenumber;
    private String email;
    private String mobilenumber;
    private Date birthdate;
    private String permitNumber;
    private String status;
    private String change;
 
    public String getTitle2() {
        return title2;
    }
 
    public void setTitle2(String title2) {
        this.title2 = title2;
    }
 
    public String getChange() {
        return change;
    }
 
    public void setChange(String change) {
        this.change = change;
    }
 
    public String getStatus() {
        return status;
    }
 
    public void setStatus(String status) {
        this.status = status;
    }
 
    public String getPermitNumber() {
        return permitNumber;
    }
 
    public void setPermitNumber(String permitNumber) {
        this.permitNumber = permitNumber;
    }
 
    public UUID getId() {
        return id;
    }
 
    public void setId(UUID id) {
        this.id = id;
    }
 
    public UUID getLoginId() {
        return loginId;
    }
 
    public void setLoginId(UUID loginId) {
        this.loginId = loginId;
    }
 
    public UUID getParentid() {
        return parentid;
    }
 
    public void setParentid(UUID parentid) {
        this.parentid = parentid;
    }
 
    public String getTitle() {
        return title;
    }
 
    public void setTitle(String title) {
        this.title = title;
    }
 
    public String getFirstname() {
        return firstname;
    }
 
    public void setFirstname(String firstname) {
        this.firstname = firstname;
    }
 
    public String getLastname() {
        return lastname;
    }
 
    public void setLastname(String lastname) {
        this.lastname = lastname;
    }
 
    public String getIdnrNationalRegister() {
        return idnrNationalRegister;
    }
 
    public void setIdnrNationalRegister(String idnrNationalRegister) {
        this.idnrNationalRegister = idnrNationalRegister;
    }
 
    public String getStreet() {
        return street;
    }
 
    public void setStreet(String street) {
        this.street = street;
    }
 
    public String getNumber() {
        return number;
    }
 
    public void setNumber(String number) {
        this.number = number;
    }
 
    public String getPostalcode() {
        return postalcode;
    }
 
    public void setPostalcode(String postalcode) {
        this.postalcode = postalcode;
    }
 
    public String getCity() {
        return city;
    }
 
    public void setCity(String city) {
        this.city = city;
    }
 
    public String getCompanyName() {
        return companyName;
    }
 
    public void setCompanyName(String companyName) {
        this.companyName = companyName;
    }
 
    public String getCompanyNumber() {
        return companyNumber;
    }
 
    public void setCompanyNumber(String companyNumber) {
        this.companyNumber = companyNumber;
    }
 
    public String getBankaccount() {
        return bankaccount;
    }
 
    public void setBankaccount(String bankaccount) {
        this.bankaccount = bankaccount;
    }
 
    public String getTelephonenumber() {
        return telephonenumber;
    }
 
    public void setTelephonenumber(String telephonenumber) {
        this.telephonenumber = telephonenumber;
    }
 
    public String getEmail() {
        return email;
    }
 
    public void setEmail(String email) {
        this.email = email;
    }
 
    public Date getBirthdate() {
        return (birthdate == null ? null : new Date(birthdate.getTime()));
    }
 
    public void setBirthdate(Date birthdate) {
        this.birthdate = (birthdate == null ? null : new Date(birthdate.getTime()));
    }
 
    public String getMobilenumber() {
        return mobilenumber;
    }
 
    public void setMobilenumber(String mobilenumber) {
        this.mobilenumber = mobilenumber;
    }
}