employeesJSPH: een JSP Webapp met HyperSQL Database (JBoss)

Deze demo applicatie is een complete JSP en JBoss gebaseerde opzet waarbij de Client functionaliteit is geïmplementeerd in JSP. Er wordt gebruik gemaakt van HyperSQL (HSQLDB) als database en de data access laag maakt gebruik van EJB en JPA om de HyperSQL database te benaderen.  Er wordt gebruik gemaakt van JAAS Authorisatie en Authenticatie, gebaseerd op de JBoss implementatie. De login functionaliteit is gerealiseerd met JavaScript die via jQuery Ajax de authenticatie services op de server aanroept. Daarbij wordt gebruik gemaakt van Servlets voor het vanuit JavaScript aanroepen van authenticatie en autorisatie services. De authenticatie en autorisatie functionaliteit maakt gebruik van user/rol gegevens opgeslagen in de database. Op basis van de toegekende autorisaties  van de ingelogde gebruikers worden menu entries ge(de)activeerd. Verder wordt gebruik gemaakt van JavaMail services voor account registratie en aanvraag nieuwe passwords. Er wordt daarvoor gebruik gemaakt van de JBoss JavaMail implementatie.

De sourcecode is beschikbaar op GitHub:

https://github.com/vanderschoot/employees/tree/master/employeesJSPH

De applicatie wordt gedraaid op een JEE server. Deze app is getest op de JBoss server. Zie artikel JBoss  JEE Server voor de benodigde configuratie van de JBoss server.

Posted in JEE, JSP | Tagged , | Leave a comment

employeesJSPSpring: een JSP/Spring Webapp met HyperSQL Database (Tomcat)

Deze demo applicatie is een complete JSP / Spring met Tomcat gebaseerde opzet waarbij de Client functionaliteit is geïmplementeerd in JSP met Spring MVC. Er wordt gebruik gemaakt van HyperSQL (HSQLDB) als database en de data access laag maakt gebruik van Spring en JPA om de HyperSQL database te benaderen.  Er wordt gebruik gemaakt van JAAS Authorisatie en Authenticatie, gebaseerd op JSP Spring Security. De login functionaliteit is gerealiseerd met JavaScript die via jQuery Ajax de authenticatie services op de server aanroept. Daarbij wordt gebruik gemaakt van Spring MVC Controllers voor het vanuit JavaScript aanroepen van authenticatie en autorisatie services. De authenticatie en autorisatie functionaliteit maakt gebruik van user/rol gegevens opgeslagen in de database. Op basis van de toegekende autorisaties  van de ingelogde gebruikers worden menu entries ge(de)activeerd. Verder wordt gebruik gemaakt van JavaMail services voor account registratie en aanvraag nieuwe passwords. Er wordt daarvoor gebruik gemaakt van de Spring JavaMail implementatie.

De sourcecode is beschikbaar op GitHub:

https://github.com/vanderschoot/employees/tree/master/employeesJSPHSpring

De applicatie wordt gedraaid op een Tomcat server. Deze app is getest op de Tomcat 7 server.

Posted in JEE, JSP, Spring | Tagged , | Leave a comment

employeesJSFHSpring: een JSF/Spring Webapp met HyperSQL Database (Tomcat)

Deze demo applicatie is een complete JSF / Spring met Tomcat gebaseerde opzet waarbij de Client functionaliteit is geïmplementeerd in JSF  Spring. Er wordt dus niet gebruik gemaakt van een aparte server applicatie. Er wordt voor de backend kant gebruik gemaakt van HyperSQL (HSQLDB) als database en de data access laag maakt gebruik van Spring en JPA om de HyperSQL database te benaderen.  Er wordt gebruik gemaakt van JAAS Authorisatie en Authenticatie, gebaseerd op de Spring Security implementatie. De login functionaliteit is gerealiseerd met JavaScript die via jQuery Ajax de authenticatie services op de server aanroept. Daarbij wordt gebruik gemaakt van Spring MVC Controllers voor het vanuit JavaScript aanroepen van authenticatie en autorisatie services. De authenticatie en autorisatie functionaliteit maakt gebruik van user/rol gegevens opgeslagen in de database. Op basis van de toegekende autorisaties  van de ingelogde gebruikers worden menu entries ge(de)activeerd. Verder wordt gebruik gemaakt van JavaMail services voor account registratie en aanvraag nieuwe passwords. Er wordt daarvoor gebruik gemaakt van de Spring JavaMail implementatie.

De sourcecode is beschikbaar op GitHub:

https://github.com/vanderschoot/employees/tree/master/employeesJSFHSpring

De applicatie wordt gedraaid op een Tomcat server. Deze app is getest op de Tomcat 7 server.

Posted in JEE, JSF, Spring | Tagged , | 5 Comments

employeesJSFH: een JSF Webapp met HyperSQL Database (JBoss)

Deze demo applicatie is een complete JSF gebaseerde opzet waarbij de Client  functionaliteit is geïmplementeerd in JSF . Er wordt dus niet gebruik gemaakt van een aparte server applicatie. Er wordt voor de backend gebruik gemaakt van HyperSQL (HSQLDB) als database en de data access laag maakt gebruik van EJB en JPA om de HyperSQL database te benaderen.  Er wordt gebruik gemaakt van JAAS Authorisatie en Authenticatie, gebaseerd op de JBoss implementatie. De login functionaliteit is gerealiseerd met JavaScript die via jQuery Ajax de authenticatie services (via Servlets) op de server aanroept. De authenticatie en autorisatie functionaliteit maakt gebruik van user/rol gegevens opgeslagen in de database. Op basis van de toegekende autorisaties  van de ingelogde gebruikers worden menu entries ge(de)activeerd. Verder wordt gebruik gemaakt van JavaMail services voor account registratie en aanvraag nieuwe passwords. Er wordt daarvoor gebruik gemaakt van de JBoss JavaMail implementatie.

De sourcecode is beschikbaar op GitHub:

https://github.com/vanderschoot/employees/tree/master/employeesJSFH

De applicatie wordt gedraaid op een JEE server. Deze app is getest op de JBoss server. Zie artikel JBoss  JEE Server voor de benodigde configuratie van de JBoss server.

Posted in JSF, Portfolio | Tagged , | Leave a comment

JSF en JQuery

Als jQuery wordt gebruikt in combinatie met JSF dan zijn er een aantal aspecten waar rekening mee moet worden gehouden. jQuery (en JavaScript) maken gebruik van referenties naar de DOM elementen van een HTML pagina. JSF zal bij vertaling van de JSF definities naar HTML een form ID met “:” als prefix plaatsen voor  alle input elementen . Dus voor de situatie:

<h:form id="frm">
    <h:inputText id="firstName" />
</h:form>

zal het input element vertaald worden naar HTML :

<input id="frm:firstName" type="text" />

Daarom moet elk form element worden voorzien van een form id, en moeten jQuery element element selectors deze ook toevoegen. Daarbij moet weer rekening worden gehouden met het special character “:”. In jQuery moeten special characters worden voorafgegaan door \\.
Dus voor bovengenoemde situatie ziet een jQuery selector van het input element er als volgt uit:

$('#frm\\:inputName')
Posted in JavaScript, JSF | Tagged , , | Leave a comment

Spring Mail

Dit is een van de artikelen uit een reeks over Spring. Zie ook de volgende delen :

Spring ondersteunt op eenvoudige wijze het verzenden van email. Hieronder wordt een voorbeeld uitgewerkt waarbij gebruik wordt gemaakt van gMail als SMTP server. Allereerst wordt in de applicatie context een bestand email-context gedefinieerd. Daarin worden ondermeer user/password opgenomen en de mail protocol instellingen. In dit geval wordt gebruik gemaakt van het TLS prototcol.

<?xml version="1.0" encoding="UTF-8"?>
<beans …>
	<bean id="mailSender" class="org.springframework.mail.javamail.JavaMailSenderImpl">
		<property name="host" value="smtp.gmail.com" />
		<property name="port" value="587" />
		<property name="username" value="yourname@gmail.com" />
		<property name="password" value="secret" />
		<property name="javaMailProperties">
	   		<props>
       	      <prop key="mail.smtp.auth">true</prop>
       	      <prop key="mail.smtp.starttls.enable">true</prop>
       	   </props>
		</property>
	</bean>

	<bean id="templateMessage" class="org.springframework.mail.SimpleMailMessage">
		<property name="from" value="sender@gmail.com"/>
		<property name="subject" value="Subject"/>
	</bean>

	<bean id="emailBean" class="org.biz.employees.model.service.EmailSessionBean">
		<property name="mailSender" ref="mailSender"/>
		<property name="templateMessage" ref="templateMessage"/>
	</bean>
</beans>

Hieronder een voorbeeld van een email service class die de mail verzending verzorgt.

@Named("emailBean")
@Service
public class EmailService {

	private MailSender mailSender;
	private SimpleMailMessage templateMessage;

	public void setMailSender(MailSender mailSender) {
		this.mailSender = mailSender;
	}

	public void setTemplateMessage(SimpleMailMessage templateMessage) {
		this.templateMessage = templateMessage;
	}

	public String sendEmail(String to, String subject, String body) {
             try {
                javax.mail.internet.InternetAddress ia =
                                              new javax.mail.internet.InternetAddress(to);
                   ia.validate();
             } catch (javax.mail.internet.AddressException e) {
    	             return “email heeft niet een juist formaat”;
             }

	    SimpleMailMessage message = new SimpleMailMessage();
	    message.setFrom("yourname@gmail.com");
	    message.setTo(to);
	    message.setSubject(subject);
	    message.setText(body);

             try {
        	         mailSender.send(message);
             } catch(MailAuthenticationException e) {
                 return e.getMessage();
             }
             return "OK";
       }
}

Hieronder een voorbeeld waarin de email service class wordt aangeroepen.

        String mailstatus = emailBean.sendEmail(email, subject,  message);
Posted in JEE, Spring | Tagged , | Leave a comment

Spring MVC

Introductie

Dit is een van de artikelen uit een reeks over Spring. Zie ook de volgende delen :

Introductie

Spring MVC organiseert de interactie (Control) tussen gebruikersinterface (View) en het Model met de business objecten. Het is gebaseerd op het MVC pattern waarbij scheiding wordt aangebracht tussen presentatie, navigatie logic en business logic. Onderstaande figuur toont de samenwerking tussen de onderdelen die hierbij een rol spelen.

  1. Een http (html of xhtml) request vanuit een browser wordt doorgestuurd naar de Spring DispatcherServlet.
  2. De Spring DispatcherServlet stuurt het request naar een controller class aan de hand van een HandlerMapping waarin de relaties tussen requests en controllers is geconfigureerd.
  3. De controller voert de benodigde verwerking uit door benadering van model classes.
  4. De controller retourneert na afloop van het werk een ModelAndView object met model data en een view naam terug naar de DispatcherServlet.
  5. De DispatcherServlet zal m.b.v. een ViewResolver de benodigde JSP (of JSF) aanroepen en daarbij de model data doorgeven om deze te laten renderen naar de benodigde presentatie. De JSP/JSF bestandsnaam wordt samengesteld o.b.v. de view naam die de controller class doorgeeft.
  6. De view zal de benodigde html output renderen en terugsturen naar de browser waar deze wordt getoond.

Om dit geheel te laten werken is een combinatie van xml bestanden en classes met annotaties nodig.

  • web.xml : definieert de DispatcherServlet als normale servlet
  • [servletnaam]-servlet.xml : definieert de ViewResolver voor de mapping van view namen naar JSP (of JSF) bestandsnamen.
  • applicationContext.xml : is het bestand met de overige Spring metagegevens met de verschillende bean configuraties om de verschillende dependency injections mogelijk te maken. Deze wordt zoveel mogelijk gebaseerd op de mogelijkheid om beans via annotaties te configureren.

Buiten deze xml bestanden worden controller classes gemaakt die worden voorzien van Spring MVC annotaties. Deze controller classes zullen de model classes benaderen voor uitvoering van het echte werk. De model classes bestaan uit DAO’s en (JPA/Hibernate) Entities. Er wordt veelal nog een extra “Service” laag toegevoegd als een facade tussen control en model classes. Maar deze kan ook worden wegbezuinigd. De zin van de servicelaag is afhankelijk van de verwachte toegevoegde waarde aan business logic die hieraan kan worden toegekend.

web.xml met DispatcherServlet

De DispatcherServlet wordt als normale servlet gedefinieerd in web.xml:

<?xml version="1.0" encoding="UTF-8"?>
<web-app xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns="http://java.sun.com/xml/ns/javaee" xmlns:web="http://java.sun.com/xml/ns/javaee/web-app_2_5.xsd" xsi:schemaLocation="http://java.sun.com/xml/ns/javaee http://java.sun.com/xml/ns/javaee/web-app_3_0.xsd" version="3.0">
  <display-name>dierentuin</display-name>
  	<servlet>
        <servlet-name>dispatcher</servlet-name>
        <servlet-class> org.springframework.web.servlet.DispatcherServlet </servlet-class>
        <load-on-startup>1</load-on-startup>
    </servlet>
    <servlet-mapping>
        <servlet-name>dispatcher</servlet-name>
        <url-pattern>/control/*</url-pattern>
    </servlet-mapping>
	<listener>
		<listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
	</listener>
	<welcome-file-list>
	    <welcome-file>index.html</welcome-file>
	</welcome-file-list>
</web-app>

[servletnaam]-servlet.xml met de ViewResolver

De DispatcherServlet krijgt in web.xml de naam “dispatcher”. Als Spring conventie houdt dat in dat er in WEB-INF/ ook een bestand dispatcher-servlet.xml ( [servletnaam]-servlet.xml) moet komen. Dit bestand is een Spring metagegevens bestand waarin de ViewResolver wordt gedefinieerd en geconfigureerd. Voor de ViewResolver wordt gespecificeerd hoe JSP (of JSF) bestandsnamen worden samengesteld. Deze worden samengesteld met de View namen die door controller classes worden geretourneerd. De prefix /jsp/ geeft aan dat deze JSP’s zich bevinden in subdirectory /jsp/. De suffix property geeft aan dat het om .jsp bestanden gaat. Dat had ook een .jsf bestand kunnen zijn. Het gaat dus om “/jsp/[Viewnaam].jsp”.

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
	xmlns:context="http://www.springframework.org/schema/context"
	xmlns:p="http://www.springframework.org/schema/p"
	xmlns:aop="http://www.springframework.org/schema/aop"
	xmlns:tx="http://www.springframework.org/schema/tx"
	xsi:schemaLocation="http://www.springframework.org/schema/beans

http://www.springframework.org/schema/beans/spring-beans-3.2.xsd


http://www.springframework.org/schema/context


http://www.springframework.org/schema/context/spring-context.xsd


http://www.springframework.org/schema/tx


http://www.springframework.org/schema/tx/spring-tx.xsd


http://www.springframework.org/schema/aop


http://www.springframework.org/schema/aop/spring-aop.xsd

	http://www.springframework.org/schema/jee http://www.springframework.org/schema/jee/spring-jee-3.2.xsd">

	<bean id="viewResolver"
              class="org.springframework.web.servlet.view.InternalResourceViewResolver"
    	      p:prefix="/jsp/" p:suffix=".jsp" />

</beans>

applicationContext.xml

applicationContext.xml is het bestand met de overige Spring metagegevens met de verschillende bean configuraties om de verschillende dependency injections mogelijk te maken. Deze wordt zoveel mogelijk gebaseerd op de mogelijkheid om beans via annotaties te configureren. De volgende tags zijn hier van belang:

  • <context:annotation-config> : geeft aan dat dependency injection via annotaties verloopt
  • <context:component-scan> : specificeert de packages waarvan de geannoteerde classes automatisch als beans worden opgenomen als Spring beans
  • <tx:annotation-driven> : geeft aan dat transactie management met annotaties wordt gespecificeerd.
  • <mvc:annotation-driven> geeft aan dat mvc via annotaties wordt gespecificeerd.
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
	xmlns:context="http://www.springframework.org/schema/context"
	xmlns:p="http://www.springframework.org/schema/p"
	xmlns:aop="http://www.springframework.org/schema/aop"
	xmlns:tx="http://www.springframework.org/schema/tx"
	xmlns:mvc="http://www.springframework.org/schema/mvc"
	xsi:schemaLocation="http://www.springframework.org/schema/beans

http://www.springframework.org/schema/beans/spring-beans-3.2.xsd


http://www.springframework.org/schema/context


http://www.springframework.org/schema/context/spring-context.xsd


http://www.springframework.org/schema/tx


http://www.springframework.org/schema/tx/spring-tx.xsd


http://www.springframework.org/schema/aop


http://www.springframework.org/schema/aop/spring-aop.xsd

	http://www.springframework.org/schema/jee http://www.springframework.org/schema/jee/spring-jee-3.2.xsd

http://www.springframework.org/schema/mvc


http://www.springframework.org/schema/mvc/spring-mvc-3.2.xsd">

	<context:annotation-config/>
	<context:component-scan base-package="org.biz.dierentuin5" />
    	<tx:annotation-driven />
    	<mvc:annotation-driven />

	<bean id="dataSource"
		class="org.apache.commons.dbcp.BasicDataSource"
		p:driverClassName="org.hsqldb.jdbcDriver" p:url="jdbc:hsqldb:mem:dierentuindb"
		p:username="sa" p:password="" />

	<bean id="entityManagerFactory"
              class="org.springframework.orm.jpa.LocalEntityManagerFactoryBean">
        <property name="persistenceUnitName" value="PU"/>
	</bean>

	<bean id="transactionManager" class="org.springframework.orm.jpa.JpaTransactionManager"
		p:entityManagerFactory-ref="entityManagerFactory" />

</beans>

Controller Classes

Hieronder een voorbeeld van een controller class voor het Hond object.
Met @Controller wordt de class als Spring controller gedefinieerd.
Met @RequestMapping wordt aangegeven met welk url pad deze wordt geadresseerd waarmee de DispatcherServlet de mapping kan maken van http request naar controller en method.
Dus voor request “http:/[host]:[port]/[project]/hond/addhond.html” wordt de method addHond() van class HondController aangeroepen.
De request “addhondpost.html” is van type “POST” en wordt aangeroepen t.b.v. een Form Submit uit Form van een JSP.

Met de return statements wordt een View naam geretourneerd waarmee een aan te roepen JSP/JSF bestandnaam wordt gemaakt. In het bestand dispatcher-servlet.xml
( [servletnaam]-servlet.xml) was als pad /jsp/*.jsp gespecificeerd. In de commentaren hieronder is te zien wat de betreffende jsp’s zijn die aangeroepen zullen worden na de returns.

In addHondPost() is te zien dat een Form veld “fldNaam” vanuit de JSP wordt meegegeven. Hierin is ook het argument “Mapmodel” te zien. Deze wordt gebruikt om model data terug te geven aan de JSP die na de return wordt aangeroepen.

De controller maakt gebruik van de geïnjecteerde DAO “HondDao” om de hond data te schrijven en lezen.

@Controller
@RequestMapping("/hond")
public class HondController  {

	@Autowired
	protected HondDAO hondDao;

	//stuur addhond.jsp form naar browser
	@RequestMapping(value = "/addhond.html", method = RequestMethod.GET)
        public String addHond() {

    	// Wordt gekoppeld aan /jsp/addhond.jsp
    	return "addhond";
	}

	//verwerk input van addhond.jsp
	@RequestMapping(value = "/addhondpost.html", method = RequestMethod.POST)
	public String addHondPost(@RequestParam(value="fldNaam", required=true) String fldNaam,
Map<String, Object> model) {

		Hond hond = new Hond();
		hond.setNaam(fldNaam);
		hondDao.save(hond);

		model.put("fldNaam", fldNaam);

		List<Hond> honden = hondDao.getAll();
		model.put("honden", honden);

	    // Wordt gekoppeld aan /jsp/honden.jsp
	    return "honden";
	}

	//stuur honden.jsp form naar browser
	@RequestMapping(value = "/honden.html", method = RequestMethod.GET)
	public String Honden(Map<String, Object> model) {

		List<Hond> honden = hondDao.getAll();
		model.put("honden", honden);

	    // Wordt gekoppeld aan /jsp/honden.jsp
	    return "honden";
	}

}

JSP bestanden

Hieronder een voorbeeld van het bestand “addhond.jsp” om een nieuwe hond toe te voegen.
Voor het form wordt de request “addhondpost.html” gedefinieerd waarmee een controller class “HondController” en method “addHondPost()” zal worden aangroepen zoals in voorgaande paragraaf besproken. Te zien is het veld “fldNaam” waarvan de waarde wordt doorgegeven aan de control class.
NB: Spring heeft een eigen “form” taglibrary om forms te gebruiken. Eigenlijk moeten ook de form fields hier gebruik van maken. In dit voorbeeld is dat niet gedaan.

<%@ taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core" %>
<%@ taglib prefix="form" uri="http://www.springframework.org/tags/form" %>
<%@ page language="java" contentType="text/html; charset=UTF-8" pageEncoding="UTF-8"%>
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
<title>Nieuwe Hond</title>
</head>
<body>
<h1>Nieuwe Hond</h1>
<form:form action="addhondpost.html">
	<table>
		<tr>
			<td>Nieuwe Hond:</td>
			<td><input type="text" name="fldNaam" size="100"/></td>
		</tr>
		<tr>
			<td colspan="2" align="center">
				<input type="submit" value="Submit" />
			</td>
		</tr>
	</table>
</form:form>
</body>
</html>

Hieronder het bestand “honden.jsp” die de lijst honden toont die door de controller class zijn doorgegeven.

<%@ taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core" %>
<%@ taglib prefix="form" uri="http://www.springframework.org/tags/form" %>
<%@ page language="java" contentType="text/html; charset=UTF-8" pageEncoding="UTF-8"%>
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
<title>Honden</title>
</head>
<body>
<h1>Honden</h1>

<c:if test="${not empty honden}" >
<ul>
	<c:forEach items="${honden}" var="hond">
			<li><c:out value="${hond.naam}" /></li>
	</c:forEach>
</ul>
</c:if>
<c:if test="${empty honden}" >
	Geen honden aanwezig.
</c:if>
<a href="/DierenTuin/control/hond/addhond.html">Nieuwe Hond</a><br/>
<a href="/DierenTuin/index.html">Home</a>
</body>
</html>

Maven dependencies

Uiteraard zijn er additionele Spring MVC modules en Servlet/JSP libraries nodig, waarvan de jar’s in Maven worden gedefinieerd.

De Spring kern :

     <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-context</artifactId>
        <version>3.2.0.RELEASE</version>
    </dependency>

De Spring Web / MVC module:

      <dependency>
	      <groupId>org.springframework</groupId>
	      <artifactId>spring-web</artifactId>
	      <version>3.2.0.RELEASE</version>
      </dependency>
      <dependency>
	      <groupId>org.springframework</groupId>
	      <artifactId>spring-webmvc</artifactId>
	      <version>3.2.0.RELEASE</version>
      </dependency>

De Spring ORM module:

  	<dependency>
  		<groupId>org.springframework</groupId>
  		<artifactId>spring-orm</artifactId>
  		<version>3.2.0.RELEASE</version>
  	</dependency>

De Servlet api:

      <dependency>
          <groupId>javax.servlet</groupId>
          <artifactId>servlet-api</artifactId>
          <version>2.5</version>
       </dependency>

Voor de in het voorbeeld gebruikte JSP toepassing is nog de volgende aanvulling nodig:

      <dependency>
	    <groupId>jstl</groupId>
	    <artifactId>jstl</artifactId>
	    <version>1.1.2</version>
      </dependency>
      <dependency>
	    <groupId>taglibs</groupId>
	    <artifactId>standard</artifactId>
	    <version>1.1.2</version>
      </dependency>
Posted in JSP, Spring, Web | Tagged , , | 1 Comment

Spring Security

Introductie

Dit is een van de artikelen uit een reeks over Spring. Zie ook de volgende delen :

Introductie

Spring biedt security functionaliteit zoals authenticatie, authorisatie in een apart project

http://static.springsource.org/spring-security/site/

De ondersteuning is enorm uitgebreid en biedt veel meer dan de standaard JEE features. Met name ook integratie met verschillende standaarden zoals LDAP, OpenID, JAAS etc.
Net als bij JEE varieert de ondersteuning van basic authenticatie, gebruik makend van standaard login forms tot custom implementaties van authenticatie logic en forms.

Het Spring authenticatie model wordt ingevuld met een serie Authenticatie Providers voor gebruik van bijv. user/passwords in een bestand , in een database, in een externe LDAP provider. Voor database opgeslagen user/passwords kan gebruik worden gemaakt van een Spring standaard datamodel met standaard SQL, of eventueel custom SQL.
Het meest interessante is eigenlijk de LDAP of de geheel custom implementatie. Met dat laatste heb je volledige vrijheid in de wijze waarop het security data model er uitziet en hoe deze is geïmplementeerd. Met name in situaties waarbij geïntegreerd moet worden met bestaande security data bronnen.
Een AuthenticatieProvider class implementeert de authenticate() method waarmee kan worden ingelogd. Deze method geeft een Authenticator object terug met daarin de credentials en de autorisaties: een lijst rollen die aan de user zijn toegekend. Deze rollen worden weer gebruikt om autorisaties toe te kennen aan url paden en methods in de xml bestanden en via annotaties.

Om security te gebruiken is een combinatie van xml bestanden en classes met annotaties nodig.

  • applicationContext.xml : dit algemene Spring bestand Spring metagegevens wordt uitgebreid met diverse bean definities voor het uitvoeren van authenticatie en authorisatie taken. Dit bestand wordt opgeknipt in deelbestanden voor de verschillende Spring onderdelen zoals bijv. data-access, email en security.
  • web.xml : definieert de SecurityFilterChain : een filter die alle url calls controleert en definieert de application context xml bestanden die worden gebruikt, waaronder die voor security.

Daarnaast kunnen classes en JSP pagina’s worden uitgebreid met security functies en kunnen authorisatie definities worden toegevoegd middels annotaties. En uiteraard moet de Maven pom.xml worden uitgebreid met aanvullende Spring security module library dependencies.

applicationContext.xml

Voor het toevoegen van de Spring security metagegevens wordt het applicationContext.xml bestand gestructureerder opgezet door deze te verdelen in losse bestandsonderdelen. We krijgen dan bijv. de volgende bestanden:

  • applicationContext.xml : de algemene metagegevens
  • data-context.xml : de data access metagegevens
  • mail-context.xml : de email resource metagegevens
  • security-context.xml : de security metagegevens
  • [dispatcher-servletnaam]-servlet.xml : t.b.v. MVC, de ViewResolver configuratie van de DispatcherServlet.

Het applicationContext.xml bestand heeft nu alleen de volgende definities:

    <context:annotation-config/>
    <context:component-scan base-package="org.biz.employees" />
    <mvc:annotation-driven />

web.xml definities

Application Context bestanddefinities

Er wordt bij voorkeur geen gebruik gemaakt van includes in applicationContext.xml maar in plaats daarvan worden de verschillende bestanden gedefinieerd in web.xml waar deze worden gedefinieerd als een parameter “contextConfigLocation” binnen de context-param tag. Deze parameter wordt vervolgens weer toegevoegd aan de DispatcherServlet.

  <context-param>
        <param-name>contextConfigLocation</param-name>
        <param-value>
            /WEB-INF/dispatcher-servlet.xml
            /WEB-INF/applicationContext.xml
            /WEB-INF/security-context.xml
            /WEB-INF/data-context.xml
            /WEB-INF/mail-context.xml
        </param-value>
  </context-param>

  <servlet>
        <servlet-name>dispatcher</servlet-name>
        <servlet-class>org.springframework.web.servlet.DispatcherServlet </servlet-class>
          <init-param>
            <param-name>contextConfigLocation</param-name>
            <param-value></param-value>
        </init-param>
  </servlet>

Deze opzet bleek nodig te zijn voor het in juiste volgorde laden van de verschillende onderdelen in de Spring Context. Er wordt hierna verder ingegaan op security-context.xml. De andere bestanden betreft andere Spring onderwerpen.

Security Filter definities

Hieronder de definities voor de security filters. Deze worden ondermeer gebruikt voor het doorgeven van de security context en het controleren van de benodigde autorisaties. Bij autorisatie conflicten kan dan een redirection naar een error page of een login page worden bewerkstelligd.

  <filter>
    <filter-name>springSecurityFilterChain</filter-name>
    <filter-class>org.springframework.web.filter.DelegatingFilterProxy</filter-class>
  </filter>

  <filter>
        <filter-name>encoding-filter</filter-name>
        <filter-class>
            org.springframework.web.filter.CharacterEncodingFilter
        </filter-class>
        <init-param>
            <param-name>encoding</param-name>
            <param-value>UTF-8</param-value>
        </init-param>
  </filter>

  <filter-mapping>
        <filter-name>encoding-filter</filter-name>
        <url-pattern>/*</url-pattern>
  </filter-mapping>

  <filter-mapping>
    <filter-name>springSecurityFilterChain</filter-name>
    <url-pattern>/*</url-pattern>
  </filter-mapping>

security-context.xml

Het bestand security-context.xml hebben we gedefinieerd om de security context definities te bevatten.
Hieronder een voorbeeld invulling voor een custom AuthenticationProvider.

<?xml version="1.0" encoding="UTF-8"?>
<beans
    xmlns="http://www.springframework.org/schema/beans"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xmlns:security="http://www.springframework.org/schema/security"
    xsi:schemaLocation="http://www.springframework.org/schema/beans

http://www.springframework.org/schema/beans/spring-beans-3.1.xsd


http://www.springframework.org/schema/security


http://www.springframework.org/schema/security/spring-security-3.1.xsd">

   <security:global-method-security secured-annotations="enabled" />

   <security:http auto-config="true" use-expressions="true" access-denied-page="/jsp/noaccess.jsp">
 <security:intercept-url pattern="/jsp/login.jsp" access="permitAll" />
         <security:intercept-url pattern="/control/util/**" access="hasRole('ROLE_ANONYMOUS')" />
         <security:intercept-url pattern="/control/user/**" access="hasRole('ROLE_ADMINISTRATOR')" />
         <security:intercept-url pattern="/control/role/**" access="hasRole('ROLE_ADMINISTRATOR')" />
         <security:intercept-url pattern="/control/department/**" access="hasRole('ROLE_USER')" />
         <security:intercept-url pattern="/control/employee/**" access="hasRole('ROLE_USER')" />
         <security:form-login login-page="/jsp/login.jsp"
                              login-processing-url="/loginProcess"
                              default-target-url="/jsp/index.jsp"
                              authentication-failure-url="/login.jsp?login_error=1"/>
         <security:logout logout-url="/logout" logout-success-url="/jsp/login.jsp" />
   </security:http>

   <security:authentication-manager alias="authenticationManager">
        <security:authentication-provider ref="customAuthenticationProvider" >
        </security:authentication-provider>
    </security:authentication-manager>

    <bean id="customAuthenticationProvider"
class="org.biz.employees.model.service.CustomAuthenticationProvider"/>
   </beans>

Als eerste wordt de volgende definitie toegevoegd om security annotaties te activeren:

  <security:global-method-security secured-annotations="enabled" />

Vervolgens worden toegevoegd:

  • een <security:http> tag met de authenticatie en autorisatie configuratie
  • een <security:authentication-manager> tag met de specificatie van de AuthenticationManager bestaande uit een of meer AuthenticationProviders, gedefinieerd in sub-tags
  • één of meer beans die de Authentication Providers specificeren. Dat kunnen standaard Spring providers zijn of eigen custom provider classes. Spring biedt diverse soorten voor bijv. user/passwords in bestandvorm, database opslag, externe LDAP providers, etc.

Custom Authentication Provider

Hieronder de voorbeeld definitie van een custom Authenticatie Provider. Deze definieert een custom class als sub-class van AuthenticationProvider. Deze custom class wordt met een bean tag expliciet gedefinieerd. Zie verderop voor een voorbeeld van de custom AuthenticationProvider class.

   <security:authentication-manager alias="authenticationManager">
        <security:authentication-provider ref="customAuthenticationProvider" >
        </security:authentication-provider>
    </security:authentication-manager>

    <bean id="customAuthenticationProvider"
  	  class="org.biz.employees.model.service.CustomAuthenticationProvider"/>

HTTP Authenticatie en Autorisatie definities

Hieronder de voorbeeld definitie van de security:http authenticatie en auorisatie definities.
NB: Autorisaties kunnen ook worden gedefinieerd in classes en JSP forms.

De <security:http> tag is een container voor inliggende definities. Hier wordt met een attribuut een page url gespecificeerd die wordt getoond bij het benaderen van een pagina zonder benodigde autorisatie.

De <security:intercept-url> tags specificeren de authorisaties. In het access attribuut worden de rollen gespecificeerd. Dat kan op 2 manieren: door het invullen van de “ROLE_xxx” teksten of met expression language (EL). Met het “use-expressions” attribuut wordt de ene of de andere manier ingesteld. Hieronder wordt gebruik gemaakt van EL.

Met de <security:form-login> tag wordt een custom login form gedefinieerd. Dat hoeft niet, als je deze weglaat zal Spring een eigen default login form gebruiken.

Met de <security:logout> tag wordt een logout url gespecificeerd waarmee de logout actie wordt uitgevoerd. Deze wordt voor een succesmelding gekoppeld aan een page url, wat ook de login page kan zijn.

   <security:http auto-config="true" use-expressions="true" access-denied-page="/jsp/noaccess.jsp">
 <security:intercept-url pattern="/jsp/login.jsp" access="permitAll" />
         <security:intercept-url pattern="/control/util/**" access="hasRole('ROLE_ANONYMOUS')" />
         <security:intercept-url pattern="/control/user/**" access="hasRole('ROLE_ADMINISTRATOR')" />
         <security:intercept-url pattern="/control/role/**" access="hasRole('ROLE_ADMINISTRATOR')" />
         <security:intercept-url pattern="/control/department/**" access="hasRole('ROLE_USER')" />
         <security:intercept-url pattern="/control/employee/**" access="hasRole('ROLE_USER')" />

         <security:form-login login-page="/jsp/login.jsp"
                             login-processing-url="/loginProcess"
                             default-target-url="/jsp/index.jsp"
                             authentication-failure-url="/login.jsp?login_error=1"/>
         <security:logout logout-url="/logout" logout-success-url="/jsp/login.jsp" />
   </security:http>

Custom AuthenticationProvider class

De custom AuthenticationProvider class ziet er ruwweg als volgt uit:

public class CustomAuthenticationProvider implements AuthenticationProvider  {

	@Override
	public Authentication authenticate(Authentication authentication) throws
AuthenticationException {
		String userName = authentication.getName();
		Object credentials = authentication.getCredentials();
		//Implement custom userName/password check
		List<GrantedAuthority> authorities = new ArrayList<GrantedAuthority>();
		authorities.add(new SimpleGrantedAuthority("ROLE_USER"));
		return new UsernamePasswordAuthenticationToken(userName, credentials, authorities);

	@Override
	public boolean supports(Class<? extends Object> authentication) {
		return authentication.equals(UsernamePasswordAuthenticationToken.class);
	}
}

In de AuthenticationProvider wordt de custom logic toegevoegd om de username en password (credentials) te checken. Bijv. door hierin een data-access service te benaderen of een externe provider te benaderen. Verder wordt een zogenaamd Authentication object retour gegeven waarin de credentials incl. de authorisaties zijn toegevoegd.
De authorisaties worden opgeslagen in een List van het GrantedAuthority object en hebben de structuur “ROLE_” gevolgd door de rolnaam. Deze rol definities worden gebruikt om url paden en methods te voorzien van authorisaties. In het voorbeeld hiervoor wordt hard coded een rol “ROL_USER” toegevoegd, maar in de praktijk worden de rollen die als rechten aan een gebruiker zijn toegekend uiteraard ergens ander vandaan gehaald.

Gebruik van login form

Hieronder een voorbeeld van een custom JSP login form.

<%@ taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core" %>
<%@ taglib prefix="fmt" uri="http://java.sun.com/jsp/jstl/fmt" %>
<%@ taglib prefix="form" uri="http://www.springframework.org/tags/form" %>
<%@ taglib prefix="sec" uri="http://www.springframework.org/security/tags" %>

<%@ page import="org.springframework.security.web.authentication.UsernamePasswordAuthenticationFilter" %>
<%@ page import="org.springframework.security.web.WebAttributes" %>
<%@ page import="org.springframework.security.core.AuthenticationException" %>

<html>
<body>
<h1>Login</h1>

	<form name="f" action="<c:url value="/loginProcess" />" method="post">
		<table>
			<tr>
				<td>Username:</td>
				<td><input type="text"
						 name="j_username"
						 id="j_username" <c:if test="${not empty param.login_error}">value="<%= session.getAttribute(UsernamePasswordAuthenticationFilter.SPRING_SECURITY_FORM_USERNAME_KEY) %>"</c:if> /></td>
			</tr>
			<tr>
				<td>Password:</td>
				<td><input type="password" name="j_password" id="j_password" /></td>
			</tr>
			<tr><td colspan="2" align="center"><input name="submit" id="submit" type="submit" value="Login" /></td></tr>
		</table>
	</form>
	<c:if test="${not empty param.login_error}">
		<font color="red">
			Login fout!<br />
			Oorzaak: <%= ((AuthenticationException) session.getAttribute(WebAttributes.AUTHENTICATION_EXCEPTION)).getMessage() %>
		</font>
	</c:if>

<sec:authorize access="isAuthenticated()">
   Je bent ingelogd!
</sec:authorize>

</body>
</html>

Gebruik van programmatische login

Naast gebruik van een default of custom login form, kan ook programmatisch een login worden uitgevoerd. Bijv. een scenario waarbij login via JavaScript en Ajax (bijv. via jQuery) wordt gedaan en de login user/password encrypted naar een login service worden gestuurd.
Hierna een code voorbeeld waarbij de authenticate() method van de custom AuthenticationProvider wordt aangeroepen.
Als eerste wordt met de user/password een token object gemaakt met behulp van de Spring class UsernamePasswordAuthenticationToken. Dit token is input voor de authenticate() method. Eventueel kan aan het token met de setDetails() method nog aanvullende specifieke security data worden toegevoegd. De authenticate() method geeft een Authentication object retour welke wordt opgeslagen in de Spring security context. Het Authentication kan naar behoefte worden opgevraagd om de inlog status te checken.

UsernamePasswordAuthenticationToken token =
new UsernamePasswordAuthenticationToken(username, password);
//token.setDetails(…any object with specific data…);
try {
   Authentication auth = authenticationManager.authenticate(token);
   SecurityContext securityContext = SecurityContextHolder.getContext();
   securityContext.setAuthentication(auth);
} catch (BadCredentialsException e) {
   …
}

Hieronder een voorbeeld van het opvragen van de inlog status. Eerst wordt het Authentication object opgevraagd uit de security contect. Vervolgens kan hierop met de isAuthenticated() method worden vastgesteld of de user is ingelogd. Verdere gegevens zoals username kunnen verder worden opgevraagd.

Authentication auth = SecurityContextHolder.getContext().getAuthentication();
String userName = auth.getName();
if (auth.isAuthenticated()) {
return …;
} else {
	return …;
}

Authorisatie definities in Classes en (JSP) Forms

Behalve het autoriseren van url’s kunnen ook class methods van bijv. een DAO class worden geauthoriseerd met de annotatie @Secured(). In onderstaand voorbeeld wordt de method delete() geauthoriseerd voor de rol “ROLE_ADMINISTRATOR”.

@Secured ({"ROLE_ADMINISTRATOR"})
public void delete(User user) {
   …
}

In JSP forms kunnen autorisaties worden gecontroleerd met de sec:authorize tag:
Dat kan op 2 manieren: door het invullen van de “ROLE_xxx” teksten of met expression language (EL). De keuze hiervoor wordt ingesteld in het security-context.xml bestand met het “use-expressions” attribuut :.

Hieronder wordt gebruik gemaakt van “ROLE_xxx” tekst.

<sec:authorize ifAllGranted="ROLE_ ADMINISTRATOR ">
…
</sec:authorize>

Hieronder wordt gebruik gemaakt van EL.

<sec:authorize access="isAuthenticated()">
   Je bent ingelogd!
</sec:authorize>

Maven dependencies

Hieronder de gebruikte Maven dependencies. Omdat Spring Security een apart Spring project is zijn de versies ook afwijkend t.o.v. de algemene Spring core versies.

	<dependency>
	        <groupId>org.springframework.security</groupId>
	        <artifactId>spring-security-core</artifactId>
	        <version>3.1.3.RELEASE</version>
	</dependency>
	<dependency>
	        <groupId>org.springframework.security</groupId>
	        <artifactId>spring-security-web</artifactId>
	        <version>3.1.3.RELEASE</version>
	</dependency>
	<dependency>
	        <groupId>org.springframework.security</groupId>
	        <artifactId>spring-security-config</artifactId>
	        <version>3.1.3.RELEASE</version>
	</dependency>
	<dependency>
	        <groupId>org.springframework.security</groupId>
	        <artifactId>spring-security-taglibs</artifactId>
	        <version>3.1.3.RELEASE</version>
	</dependency>

Posted in JEE, Security, Spring | Tagged , | Leave a comment

JSP : MVC met Servlets

Introductie

Dit is een artikel uit een reeks over JSP . Zie ook de volgende delen :

JSP’s worden meestal gebruikt in een Model-View-Control patroon :

  • View: is ingevuld met JSP pagina’s (1).
  • Control: is ingevuld met Servlet’s :
    • Behandelen JSP Form inputs (2)
    • Benaderen Model Classes voor verwerking en opslag (3)
    • Openen nieuwe JSP’s met forward() calls na afloop van de Model verwerking (4)
  • Model: is ingevuld met verschillende mogelijke Java Classes zoals : andere Servlets, JavaBeans, EJB’s, Webservices, etc. Hier bevindt zich de business logic en gegevensopslag. Een veel gebruikte invulling is Data Access Objects (DAO) die een gegevensinterface bieden naar een opslag technologie zoals JPA Entities. Eventueel bevindt zich boven de DAO nog een service laag met de business logic. Naast DAO kunnen zich nog andere interfaces en resources bevinden zoals webservices, message queue’s etc.

Onderstaande figuur geeft het schematisch weer:

Hierna worden voorbeelden gegeven van de verschillende MVC componenten:

  • EmployeeController.java : De servlet die de JSP pagina’s inputs behandelt en een EmployeeDAO EJB benadert voor data.
  • employee.jsp: De JSP page met form voor het maken en bewerken van employees.
  • employeeList.jsp: De JSP page met een table voor het tonen van een employee list.
  • web.xml: De deployment descriptor met de configuratie van de controller servlet.

Er wordt gebruik gemaakt van een EmployeeDAO EJB voor het benaderen van gegevens in een database.

Controller Servlet : EmployeeController.java

De servlet bevat een doPost() en een doGet() method.
doGet() : behandelt url requests van de browser en van foward() calls en wordt gestuurd door een url parameter “action” wat betreft de benodigde dao acties en de forward naar de volgende JSP pagina’s employee.jsp of employeeList.jsp.
doPost() behandelt de form input van employee.jsp, voert een dao save() of update() uit, vraagt met dao.getAll() de nieuwe employee list, afgesloten met een forward naar employeeList.jsp.
Met een request.setAttribute() call wordt de list “employees” opgeslagen in het request zodat de employeeList.jsp deze kan lezen en tonen.

public class EmployeeController extends HttpServlet {
    @EJB private EmployeeDAO dao;
    private static String EDIT = "/employee.jsp";
    private static String LIST = "/employeeList.jsp";

    protected void doGet(HttpServletRequest request, HttpServletResponse response) throws
ServletException, IOException {
        String action = request.getParameter("action");
        List<Employee> list;
        int id;
        if (action.equalsIgnoreCase("delete")){
            id = Integer.parseInt(request.getParameter("employeeId"));
            dao.delete(id);
            forward = LIST;
            list = dao.getAll();
            request.setAttribute("employees", list);
        } else if (action.equalsIgnoreCase("edit")){
            forward = EDIT;
            id = Integer.parseInt(request.getParameter("employeeId"));
            Employee emp = dao.findById(id);
            request.setAttribute("employee", emp);
        } else if (action.equalsIgnoreCase("list")){
            forward = LIST;
            list = dao.getAll();
            request.setAttribute("employees", list);
        } else {
            forward = EDIT;
        }
        RequestDispatcher view = request.getRequestDispatcher(forward);
        view.forward(request, response);
    }

    protected void doPost(HttpServletRequest request, HttpServletResponse response) throws
ServletException, IOException {
        Employee emp = new Employee();
        String firstName = request.getParameter("firstName"); emp.setFirstName(firstName);
        String lastName = request.getParameter("lastName"); emp.setLastName(lastName);
        String sbirthDate = request.getParameter("birthDate");
        Date birthDate = null;
        String employeeId = request.getParameter("employeeId");
        String departmentId = request.getParameter("departmentId");
        try {
             birthDate = new SimpleDateFormat("yyyy-MM-dd").parse(sbirthDate);
             emp.setBirthDate(birthDate);
        } catch (ParseException e) {
             e.printStackTrace();
        }
        if(employeeId == null || employeeId.isEmpty())
        {
            dao.save(emp);
        } else {
    	    int id = Integer.parseInt(employeeId);
            emp.setEmployeeId(id);
	    dao.update(id, emp);
        }
        view = request.getRequestDispatcher(LIST);
        List<Employee> list = dao.getAll();
	request.setAttribute("employees", list);
	view.forward(request, response);
    }
}

JSP Form : employee.jsp

Deze JSP pagina bevat een form voor het aanmaken of bewerken van employees.
In geval van het bewerken van een bestaande employee wordt de value van de form fields ingesteld op de JavaBean properties van de employee die als object in het request object is opgeslagen door de EmployeeController servlet met de setAttribute() method.
Het form specificeert als action de EmployeeController servlet.
De form fields hebben elk een name attribuut waarmee ze als parameter kunnen worden ingelezen in de EmployeeController servlet.

<%@ page language="java" contentType="text/html; charset=ISO-8859-1" pageEncoding="ISO-8859-1"%>
<%@ taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core" %>
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1">
<title>Add/Edit Employee</title>
</head>
<body>
	<h1>Add/Edit Employee</h1>
    <form method="POST" action="EmployeeController" name="frm">
    <table>
        <tbody>
        <tr><td>Id :         </td><td><input type="text" readonly="readonly" name="employeeId"
value="${employee.employeeId}" /></td></tr>
        <tr><td>First Name : </td><td><input type="text" name="firstName"
value="${employee.firstName}" /></td></tr>
        <tr><td>Last Name  : </td><td><input type="text" name="lastName"
value="${employee.lastName}" /></td></tr>
        <tr><td>Birthdate  : </td><td><input type="text" name="birthDate"
value="${employee.birthDate}" /></td></tr>
        <tr><td><input type="submit" value="Submit" /></td><td></td></tr>
        </tbody>
    </table>
    </form>
</body>
</html>

JSP Result : employeeList.jsp

Deze JSP pagina bevat een tabel met de list “employees” zoals deze is opgeslagen in het request object door de EmployeeController servlet met de setAttribute() method.
In de tabel worden extra kolommen weergegeven voor de delete en update acties met een url request naar de EmployeeController die daarmee een dao.delete(), resp. de JSP pagina employee.jsp zal openen.
Onderaan de tabel staat nog een insert actie middels een url request naar de EmployeeController die daarmee de JSP pagina employee.jsp zal openen voor het invoeren van een nieuwe employee.
Gedemonstreerd wordt hoe de tag wordt gebruikt om de lijst te maken met het “employees” object die via de ${employees} expressie wordt benaderd.

<%@ page language="java" contentType="text/html; charset=ISO-8859-1" pageEncoding="ISO-8859-1"%>
<%@ taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core" %>
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1">
<title>Employees</title>
</head>
<body>
<h1>Employees</h1>
    <table border=1>
        <thead>
            <tr>
                <th>Employee Id</th>
                <th>First Name</th>
                <th>Last Name</th>
                <th>Birthdate</th>
                <th colspan=2>Action</th>
            </tr>
        </thead>
        <tbody>
            <c:forEach items="${employees}" var="emp">
                <tr>
                    <td><c:out value="${emp.employeeId}" /></td>
                    <td><c:out value="${emp.firstName}" /></td>
                    <td><c:out value="${emp.lastName}" /></td>
                    <td><c:out value="${emp.birthDate}" /></td>
                    <td><a href="EmployeeController?action=edit&employeeId=<c:out value="${emp.employeeId}" />">Update</a></td>
                    <td><a href="EmployeeController?action=delete&employeeId=<c:out value="${emp.employeeId}" />">Delete</a></td>
                </tr>
            </c:forEach>
        </tbody>
    </table>
    <p><a href="EmployeeController?action=insert">Add Employee</a></p>
</body>
</html>

Deployment Descriptor : web.xml

Onderstaande web.xml deployment descriptor specificeert de EmployeeController servlet.
(Dat kan uiteraard ook zonder web.xml met de annotaties).

<?xml version="1.0" encoding="UTF-8"?>
<web-app xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns="http://java.sun.com/xml/ns/javaee" xmlns:web="http://java.sun.com/xml/ns/javaee/web-app_2_5.xsd" xsi:schemaLocation="http://java.sun.com/xml/ns/javaee http://java.sun.com/xml/ns/javaee/web-app_3_0.xsd" version="3.0">
  <display-name>employeesJSPH</display-name>
  <servlet>
    <description></description>
    <display-name>EmployeeController</display-name>
    <servlet-name>EmployeeController</servlet-name>
    <servlet-class>org.biz.employees.control.EmployeeController</servlet-class>
  </servlet>
  <servlet-mapping>
    <servlet-name>EmployeeController</servlet-name>
    <url-pattern>/EmployeeController</url-pattern>
  </servlet-mapping>
  <welcome-file-list>
    <welcome-file>index.jsp</welcome-file>
  </welcome-file-list>
</web-app>
Posted in JEE, JSP | Tagged | Leave a comment

JSP en gebruik van data

Introductie

Dit is een artikel uit een reeks over JSP . Zie ook de volgende delen :

JSP pagina’s moeten natuurlijk gebruik maken van data : om weer te geven en om gebruikersinvoer te verzamelen en naar de server naar servlets (of andere JSP pagina’s) te versturen. Er zijn hiervoor een aantal technieken beschikbaar zoals form parameters, JavaBean objecten en session attributen. Verzamelde form parameters worden aan serverzijde in een servlet ingelezen via request.getParameter(). Aan serverzijde kan een servlet een JavaBean opslaan als sessie attribuut via request.setAttribute(). Met een forward() call wordt een JSP pagina geopend die de sessie attribute als JavaBean kan benaderen. JSP kent verschillende JavaBean acces technieken om deze in pagina’s te gebruiken en weergeven. De meest eenvoudige is via Expression Language (EL) $(bean).

De getParameter() en setAttribute() methods worden uitgevoerd op het Request object. Deze is binnen JSP één van de standaard JSP objecten (implicit objects).

JavaBeans

JavaBeans kunnen worden benaderd met deaction tags of met de ${bean} Expression Language. Detag biedt de,enmogelijkheden om een JavaBean variabele te definiëren en vervolgens de properties te gebruiken.

Hieronder een voorbeeld van <jsp: > gebruik:

<jsp:useBean id="employee" class="org.biz.Employee">
<jsp:setProperty name=" employee " property="name" value="Jan"/>
</jsp:useBean>

<p>Employee name : <jsp:getProperty name="employee" property="name"/></p>

JSP Expression Language (EL)

De JSP Expression Language biedt een taal om applicatie data te benaderen, evalueren en andere expressies mee uit te voeren. De EL kan worden gebruikt om JSP tag attributen in te stellen en het vereenvoudigt het gebruik van JavaBean properties voor bewerkingen en weergave.

JSP EL wordt gebruikt tussen de haken ${ }. De JSP compiler zal de code tussen deze haken evalueren en hiervoor code genereren die het resultaat daarvan zal produceren op de betreffende plek in de JSP pagina.

Bijv:

<p>
Oppervlakte =  ${lengte * breedte}
</p>

Met EL kunnen JavaBeans heel eenvoudig worden gebruikt zoals in het volgende voorbeeld:

<c:forEach items="${employees}" var="emp">
<c:out value="${emp.employeeId}"
</c:forEach>

Hieronder een voorbeeld waarin een expressie wordt gebruikt als test conditie in een if tag waarin twee JavaBean properties worden vergeleken:

<c:if test="${dep.departmentId == employee.department.departmentId}">
</c:if>

Standaard objecten

De volgende objecten zijn als standaard variabele in JSP pagina’s beschikbaar:

  • Request : Javax.servlet.http.httpservletrequest
  • Response : Javax.servlet.http.httpservletresponse
  • Out : Javax.servlet.jsp.JspWriter
  • Session : Javax.servlet.http.httpsession
  • PageContent : Javax.servlet.jsp.pagecontext
  • Application : Javax.servlet.http.ServletContext
  • Config : Javax.servlet.http.ServletConfig
  • Page : Java.lang.Object

Request

Het Request object bevat de gegevens die vanuit de browser naar de server worden verzonden. Het wordt echter ook gebruikt om vanuit de applicatie (servlet) gegevens terug te sturen. Nadat een servlet een forward heeft gedaan naar een nieuwe pagina zal deze bijv. JavaBean objecten en Header parameters in het request object kunnen benaderen.

Het Request object wordt aan serverzijde gebruikt om gebruikers input en browserdata te verwerken en eventueel nieuwe of aangepaste data toe te voegen. Via het Request object kunnen objecten, parameters, headers, sessions worden gelezen, gemaakt etc. Voorbeeld van enkele request methods:

  • String getParameter(String name)
  • Enumeration getParameterNames()
  • Object getAttribute(String name)
  • Enumeration getAttributeNames()
  • Enumeration getHeaderNames();

Hieronder een voorbeeld van het uitlezen van alle parameter namen:

<%
   Enumeration paramNames = request. getParameterNames ();
   while(paramNames.hasMoreElements()) {
      String paramName = (String) paramNames.nextElement();
      out.print("<tr><td>" + paramName + "</td>\n");
      String paramValue = request.getParameter(paramName);
      out.println("<td> " + paramValue + "</td></tr>\n");
   }
%>

Response

Het Response object bevat de gegevens die de server naar de browser stuurt. Het wordt aan serverzijde vanuit de applicatie (servlets, jsp’s) eigenlijk niet gebruikt. Het kan bijv. worden gebruikt om een http Status code terug te sturen:

<%
   response.sendError(407, "Need authentication!!!" );
%>

Deze zal in de browser de typische html error pagina laten zien met de aangegeven code en melding.

Out

Stuurt output naar de response bijv:

<p>
out.print("tekst zonder newline");
out.println("tekst met newline");
</p>

Session

Het Session object wordt gebruikt om data op te slaan over verschillende http requests heen.
Op deze manier wordt “conversational state” toegevoegd.

Voorbeeld van enkele session methods:

  • public void setAttribute(String name, Object value)
  • Object getAttribute(String name)
  • Enumeration getAttributeNames()
  • public String getId() //Geeft de unieke session id
<%
String name = new String("Jan");

session.setAttribute(“name”, name);
name = (String) session.getAttribute(“name”);
%>

<p><% out.print(name); %></p>

Application

Wordt gebruikt om op application level data op te slaan. Typisch voorbeeld is een hitcounter.

  • application.setAttribute(String Key, Object Value);
  • application.getAttribute(String Key);

Config

Wordt nagenoeg niet gebruikt. Kan worden gebruikt om bijv. de servlet naam op te vragen:

<p> servlet : <%=config.getServletName()%>
Posted in JEE, JSP | Tagged | Leave a comment