Tutoriel sur la création d'URLs Grails optimisées pour le SEO

publié le

Avoir des URLs optimisées pour le SEO est primordial pour votre positionnement dans Google et autres moteurs de recherche. Dans cet article je vais expliquer comment générer et gérer des URLs SEO.

Il n'existe pas de plugin magique pour Grails pour transformer les URLs en URL optimisées pour le SEO. En effet, chaque structure de site étant différente vous devez construire vous-même ces URLs.

Pour ce site, j'utilise le patron suivant pour construire les URL reliées au blog:

{domain}/blog/{blog_id}/{category_name}/{post_title}

Ex: /blog/2/grails/installing-a-grails-plugin

Vous noterez que cette forme est bien différente des URLs générées automatiquement par l'outil de scaffolding de Grails:

{domain}/{controller_name}/{action}/{id}

Ex: /blog/show/2

La première étape est de configurer Grails pour qu'il réponde aux URLs optimisées pour le SEO.

Pour cela, ajoutez un nouveau patron d'URL dans UrlMappings.groovy:

name blog: "/blog/$id/$category?/$title?" {
controller = "blog"
action = "show"
}

Le fait de nommer ce mapping est optionel, mais sera utile quand viendra le temps de générer des liens en utilisant le Taglib de Grails <g:link/>.

Grails va mapper chaque variable (les noms précédés par le signe $) dans l'objet request qui sera accessible dans le contrôleur (Blog) et l'action (show). Notez que la category et le titre du blog sont optionnels (variables finissant par le signe ?), ce qui veut dire que les URLs suivantes vont être capturées:

{domain}/blog/1
{domain}/blog/1/cat_name
{domain}/blog/1/cat_name/blog_title

A présent que Grails peut gérer ces URLS SEO, nous devons maintenant générer les liens en utilisant le Taglib de Grails <g:link/>.

La seconde étape est donc de générer les liens SEO avec le tag <g:link>. Pour cela, il faut renseigner chaque paramètre (dans notre exemple blog id, category name et blog title) que nous avons défini précédemment dans URLMappings

Prenons 2 objets de domaines:

Class Blog {
	String title
	String content
	static belongsTo = [category:Category]
}

Et:

Class Category {
	String name
}

Dans une page GSP, nous avons chargé une instance de blog pour générer un lien SEO en utilisant g:link de Grails:

<g:link  mapping="blog"
 params="[id: blogInstance.id, category: blogInstance.category.name ,title: blogInstance.title]">
  ${blogInstance.title}
</g:link>

Le code ci-dessus va générer une URL en utilisant le patron défini dans URLMappings.

{domain}/blog/{blog_id}/{category_name}/{post_title}

Tout d'abord, vous devez spécifier le nom du mapping (blog) ensuite lister chaque paramètre du patron dans params. Si vous oubliez un paramètre, l'URL va être générée mais avec tous les paramètres à la fin de l'URL (après ?). Par exemple, si nous omettons de spécifier le paramètre title, l'URL générée va ressembler à:

{domain}/blog?id=&category_name=&title=

Pas des plus jolis...

Maintenant nous avons une URL comportant des mots-clés, mais il reste un problème, tous les caractères spéciaux et les espaces vont être encodés dans l'URL:

"blog test" sera encodé en "blog%20test", etc...

Pas de plus jolis (encore)...

Mais Grails possède un plugin très utile pour ce problème http://grails.org/plugin/seofriendly-urls qui contient un portage du fichier formatting.php de Wordpress. Vous pouvez installer le plugin ou tout simplement copier le service de Github FriendlyUrlService.groovy vers votre dossier services de Grails.

Créez un nouveau service Grails:

Faites un clic droit sur un dossier de votre projet Grails et sélectionnez new > service:


Ensuite entrez le nom complet du nouveau service (incluant les packages), par exemple com.inoneo.FriendlyUrlService:


Collez le contenu de FriendlyUrlService.groovy qui provient de Github dans le service nouvellement créé.

Maintenant il faut utiliser ce service pour créer des URLs SEO. Il y a différentes façons de procéder: on peut ajouter une méthode à l'objet de domaine Blog qui va retourner le titre du blog transformé pour être utilisé dans une URL SEO. Une autre solution serait d'appeler le service directement dans le contrôleur et d'injecter une variable contenant le titre SEO à utiliser dans la GSP. Dans mes projets Grails (et Java), j'aime garder les objets de domaines ainsi que les contrôleurs simples et allégés autant que possible, en gardant la grande partie de la logique dans des services.

Comme ce service sera utile pour bon nombre d'objets de domaines, nous pouvons créer une Taglib que nous utiliserons directement dans les GSPs:

Faites un clic droit sur un dossier et sélectionnez new > TagLib:


Ensuite copiez le code suivant:

class SeoTagLib {

	static namespace = "seo"
	
	def friendlyUrlService
	
	/**
	 * Convert the value using the SEO friendly URL service.
	 *
	 * @attr String value to be converted
	 */
	def convert = { attr, body ->
		out << body() << friendlyUrlService.sanitizeWithDashes(attr.value)
	}
}

Note: Pour des questions de performance, évitez d'appeler des services transactionels dans une TagLib. En effet une nouvelle transaction sera créée à chaque appel de la Taglib. Dans notre cas FriendlyUrlService n'est pas un service transactionel:

class FriendlyUrlService {

	static transactional = false
...
}

Nous pouvons enfin créer une URL SEO en associant la TagLib seo avec g:link:

<g:link  mapping="blog"
 params="[id: blogInstance.id, category: seo.convert(value:blogInstance.category.name) ,title: seo.convert(value:blogInstance.title)]">
  ${blogInstance.title}
</g:link>

comments powered by Disqus