Welcome graphic artists! The PrettyFaces project needs a logo, and to facilitate this, we’re hosting a logo contest! Prizes: We know that your time is valuable, but because this is a completely open-source and unfunded project, we can’t offer a cash reward; however, will receive a T-shirt with your logo on it, a blog entry announcing you as the winner, a prominent spot (with link) on our contributors page, a spot (with link) on the home-page as a FAQ entry, and the satisfaction of knowing that you helped an open-source project!

Rules and encouragement:

• High-resolution, transparent-background, SVG or PNG (preferred, at least 1500×1500 px, for T-shirts)
• Should look professional and honor the project namesake.
• Cute eyelashes, and the use of cute animals or figures are both highly encouraged but not required.
• The logo should be cute, friendly, and crisp.
• The use of semi-3D perspective is encouraged, Show us something “Pretty!”
• Logos should include a round or square-ish component (such as the “question-cube” above, so that it can be iconified,) words optional but encouraged.

Submissions and voting:

Send your entries by via email to: admin@ocpsoft.com. Be sure to include:

• your name
• the entry (as a SVG/PNG attachment) – submit as many as you please
• your website or company (if you wish to be referenced should your entry be the winner)

Entries will be screened for any inappropriate graphics or potential trademark problems (we don’t want to get sued!) Voting will begin in three weeks (Monday, August 16th) unless more time is required (within reason.)

Fine print

By submitting an entry: if you win the contest, you grant us permission to use, redistribute, or modify your image in any way! We have to be able to use it, or what’s the point of giving you a T-Shirt?

Examples

This section shows some simple examples for the annotation support of PrettyFaces. For details refer to the Annotation-based configuration chapter in the current snapshot of the PrettyFaces Reference Documentation (note, this documentation will be merged into the primary PrettyFaces reference guide once released.)

Declaring a URL mapping using annotations is straight forward. Just add a @URLMapping to the class primarily responsible for the page. The annotation requires you to specify the ID of the mapping, the URL pattern and the view to render:

@URLMapping(id="login", pattern="/login", viewId="/login.jsf")
public class LoginBean {
  /* your code */
}

Path parameters can be embedded in the URL pattern as already known from the XML configuration:

@URLMapping(id="viewStory", pattern="/story/#{storyBean.currentStoryId}", viewId="/story-view.jsf")
public class StoryBean {
 
  private Long currentStoryId;
 
  /* your code */
}

To use query parameters, just annotate the target property with a @URLQueryParameter annotation. The query parameter will automatically refer to the mapping declared on the class.

@URLMapping(id="viewStory", pattern="/story/view", viewId="/story-view.jsf")
public class StoryBean {
 
  @URLQueryParameter("id")
  private Long currentStoryId;
 
  /* your code */
}

If you want to use page actions, just add a @URLAction annotation to the methods you want to be executed.

@URLMapping(id="viewStory", pattern="/story", viewId="/story.jsf")
public class StoryBean {
 
  @URLQueryParameter("id")
  private Long currentStoryId;
 
  private Story story;
 
  @URLAction
  public void loadStory() {
 
    // load the story 
    story = myStoryDao.getById( currentStoryId );
 
  }
 
  /* more code */
 
}

Please note that all annotations accept a wide range of additional options to customize the mapping. As they are very similar to the well known syntax of the classic XML configuration you should quickly get familiar with them.

Give it a try

Want to take a look at the new annotations support in PrettyFaces? Please do! We are always looking for people helping us testing the new features.

The current snapshots are regularly deployed to the following Maven repository:

<repository>
  <id>ocpsoft</id>
  <name>OcpSoft</name>
  <url>http://ocpsoft.com/repository/</url>
  <releases>
    <enabled>true</enabled>
  </releases>
  <snapshots>
    <enabled>true</enabled>
  </snapshots>
</repository>

Depending on your JSF version, add the PrettyFaces dependency to your Maven pom.xml:

For JSF 2.0:

<dependency>
  <groupId>com.ocpsoft</groupId>
  <artifactId>prettyfaces-jsf2</artifactId>
  <version>3.0.2-SNAPSHOT</version>
</dependency>

For JSF 1.2:

<dependency>
  <groupId>com.ocpsoft</groupId>
  <artifactId>prettyfaces-jsf2</artifactId>
  <version>3.0.2-SNAPSHOT</version>
</dependency>

PrettyFaces will support annotations out of the box, nevertheless, it is strongly recommended to specify the packages to scan for annotations; just add the following configuration to your web.xml:

<context-param>
  <param-name>com.ocpsoft.pretty.BASE_PACKAGES</param-name>
  <param-value>com.example.myapp</param-value>
</context-param>

That’s it! If you have any feedback or questions, please ask on the OcpSoft Support Forums, or the OcpSoft Users Group Mailing List. For more information, visit the PrettyFaces home page. Thanks!

Voting ends Friday May 21st, so act now!

1. You’ll need to register for an account on JBoss.org (Remember when creating an account that you’ll need to use a valid email address for registration confirmation!)
2. Vote – for “Beautiful Java EE: Use PrettyFaces to Harness SEO, Improve User Exp, and Ease Dev by Lincoln Baxter” – otherwise known as “Beautiful Java EE: Next-generation web application for next-generation web users.”
3. If you have problems voting after registration, log out, clear your cookies, log in, then navigate back to the contest and vote.

Do your part: Vote!

]]> http://ocpsoft.com/opensource/vote-for-prettyfaces-at-judcon-jboss-world-red-hat-summit/feed/ 1 http://ocpsoft.com/opensource/announcing-prettyfaces-2-0-4-url-rewriting-for-javaserver-faces-jsf2/ http://ocpsoft.com/opensource/announcing-prettyfaces-2-0-4-url-rewriting-for-javaserver-faces-jsf2/#comments Fri, 19 Feb 2010 22:31:15 +0000 Lincoln http://ocpsoft.com/?p=1041

Add PrettyFaces to an existing JSF2 application less than 5 minutes:

• Non-invasive! – never change your application internals, simply lay PrettyFaces on to an existing application.
• Zero configuration* in a Servlet 3.0 environment – PrettyFaces core classes are automatically registered with the servlet container and JavaServer Faces. (No need to modify web.xml!)
• Rapid development via automatic configuration reloading (when java.faces.PROJECT_STAGE = Development)

• Custom Inbound/outbound URL rewriting rules – with built in support for canonicalization such as appending or removing trailing slashes, lowercasing, custom rewrites, and more.
• Enhanced SEO and Rewriting support – including the ability to choose 301, 302, or internal redirects.
• Outbound URL mapping rewriting – removes the need for <pretty:link> now <h:link> can be used to generate pretty, SEO-friendly URLs.
• Named pattern / path-parameters – for integration with JSF2 and non-JSF applications – not all applications support EL, but they all understand ServletRequest.getParameter(…)

Maven Dependency

<dependency>
	<groupId>com.ocpsoft</groupId>
	<artifactId>ocpsoft-pretty-faces</artifactId>
	<version>2.0.4</version>
</dependency>

The Beginning

When we started OcpSoft, we were working on what is now ScrumShark – using JSF 1.2 , Hibernate, and many other technologies.  At first it was very overwhelming, challenging to figure out which technologies to use; though, even after we had chosen our technology stack, we fought with poor documentation, lack of support, and integration as we explored new features of the stack.

During that time Lincoln saw a need for pretty URLs, because what was currently on the market wasn’t intuitive, and was painful to work with.  The enhancements we requested weren’t getting approved or were too slow coming, even providing patches.  So Lincoln set out to do it himself, and as he puts it: “destroyed Thanksgiving 2008.”

PrettyFaces

Thanks to PrettyFaces, Lincoln dug-in to JSF and started to really understand the inner workings of both problem and solution; within a few weeks of releasing version one, we were seeing many supporters.  Soon after, Lincoln was contacted by Dan Allen from JBoss/Red Hat, and started assisting him with an enhancement to JSF’s navigation system.

During that same time Lincoln convinced us – at OcpSoft – to start using JSF 2 Beta to build ScrumShark.  JSF 2 was undergoing continuous changes at that time, and the specification wasn’t even public, so we were seeing different results in our application every week.  Lincoln started posting the issues on the JSF 2 mailing list, and quickly became known as the JSF 2 tester, bug-finder.  Without ScrumShark, and Lincoln willing to take a chance on a bleeding edge technology, I don’t think the JSF 2 team would have found and fixed all the bugs as fast as they did.  Not too long after this, he joined the JSF Expert Group and was presenting PrettyFaces at JSFSummit.

Congratulations Lincoln!

He just got a job with JBoss at Red Hat, as a Senior Software Engineer. I am proud of of what my partner and best friend Lincoln has accomplished.

All of the feedback was outstanding, from “Most interesting presentation,” to “Best, most entertaining presentation” – and I should sure hope so. There was a little surprise that everyone seemed to enjoy – read carefully and you’ll find it. (Hint, it’s on page 22.)

Below is a photo taken by one of the attendees – the only proof that the talk actually happened, aside from this. In any case, keep your eyes on PrettyFaces for some cool new features in the next releases – work is still going strong.

Lincoln Baxter, III presents PrettyFaces at JSFSummit2009

Three Fundamentals of Search Optimization:

1. Content – Actually providing real, relevant information.

2. Credibility – Having external validation that your content is real, relevant

3. Context – Confirming to Search Engines that your content is credible in the context where it is used.

HTML links – Your ammunition, spend wisely:

When you promote your site, instead of linking this way:

Consider linking this way:

Notice the title of the URL when you hover your mouse. (You could also include those words in the link text itself to achieve the same goal.)

Let’s assume this second link is found in a comment on a blog related to any of “Scrum,” “Agile,” “Online,” “Project,” “Management,” or “Tool”:

1. Content – Your link now uses keywords found in it’s own address or title. Those keywords also exist in the page to which it points (+ SEO Points)
2. Credibility – You have another external link to your website (+ SEO Points)
3. Context – Your link lives on a page with keywords similar to those used in the link itself, and you provided it in a way that added value to those who read it (+ SEO Points, + Reputation: You look like you know what you are talking about)

Assuming this second link is found in a comment on your local grocery store website:

1. Content – Your link now uses keywords found in it’s own address. Those same keywords exist on the site to which it points (+ SEO Points)
2. Credibility – You have another external link to your website (+ SEO Points)
3. Context – Your link lives on a page that is completely unrelated to the business goals, or the link itself (- SEO Points, – Reputation: You look stupid)

The more, better trusted, well known sites you have linking to yours, the more powerful these factors become – even the negatives.

However, there is one more thing you can do that is possibly more powerful.

Put the keywords IN the URL HREF:

If the link URL (the content of the link href=”…” attribute) contains the keywords you are attempting to optimize, the reward from search engines may be even greater! How many times have you done a search, and the results highlighted keywords in the URL of the top results? Well… we can do that in JSF, and our custom web-applications, too.

Even better, that link can contain the keywords and be human readable, self-promoting. When people can read the text of a link they receive over Instant Messenger, or Email, they are much more likely to click it. I know I personally distrust links that I can’t understand. – for example:

“We hold these truths to be self evident”#

1. Pretty URLs look nicer, relay your content to search engines better, and people are more likely to click/remember/send-to-a-friend something that they can understand and process – both internally and externally to your site.
2. Pretty URLs will create better anchor/hover text if the link title is left blank. Just look at the browser “heads up” text when you hover over a link.
3. If you later change technologies, and have “.tech/.jsf/.seam/.do” extensions in your URLs, you’ve just instantly lost all SEO progress. Your content is now at a different location; you start over unless you have the ability to do perform 301 redirect (Moved Permenantly) to the new page from the old address. Search engines generally punish sites who use redirects.

Methods to put keywords in URLs, with or without PrettyFaces…

Assuming your content is relevant to the context you are linking from, and you know actually know what you are talking about…

Physical file per-URL:

http://example.com/ex/faces/store/how-to-improve-seo-with-prettyfaces-book.jsf

• Readable – SEO friendly
• No dynamic information provided – for each new url, a new file… why are you using JSF?
• No extra configuration required – you don’t need PrettyFaces

• Horrible to use in faces-config.xml navigation or <h:link>
• URL suffers from the tech-conversion issue ( *.jsf ) (Truth #3)

Query parameters in URL:

http://example.com/ex/store.jsf?item=how-to-improve-seo-with-prettyfaces-book

• A little less readable, still SEO friendly
• Anchor/hover text may not be so nice
• URL is still technology dependent unless you remove the ( *.jsf ) extension with PrettyFaces (Truth #3)

<url-mapping id="store">
	<pattern>/store</pattern>
	<query-param name="item">#{itemBean.item}</query-param>
	<view-id>/faces/store.jsf</view-id>
	<action> #{itemBean.load} </action>
</url-mapping>

Path parameters in URL:

http://example.com/ex/store/how-to-improve-seo-with-jsf-and-prettyfaces-book

• Most readable, still very SEO friendly (Truth #1)
• Best “heads up”/anchor text (Truth #2)
• URL is technology independent (Truth #3)
• Even easier to implement than query-parameters

<url-mapping id="store">
	<pattern>/store/#{itemBean.item}</pattern>
	<view-id>/faces/store.jsf</view-id>
	<action> #{itemBean.load} </action>
</url-mapping>

So here, if your technology can support pretty URLs, like PrettyFaces does for JSF, then you can SEO yourself to heaven. Remember, though, that SEO is only one of many marketing techniques to use in the new technological age. Maybe your target audience is on the radio, maybe they are actually in grocery stores; the point is, find your audience and market to them where they are most willing to see your information, and take action. SEO may not be the best answer for you – before investing too much time and hard earned money, consider your options.

No matter what technology you use…

Follow at least these three guidelines:

1. Content – Actually provide real content, put keywords in <h1>header</h1> tags. (+ SEO Points, + Reputation)
2. Consistency – Make sure your URLs use main keywords found on the page you are displaying. (+ SEO Points, + Reputation)
3. Context – If it’s not adding value, or is not relevant, don’t post it. (- SEO Points, – Reputation: You look stupid)

And you might want to protect yourself from a technology change. That’s just the worst way to go out of a well optimized site, into the pits of search listings nobody will see – of course, it means your next technology also needs to support pretty URLs

Coinciding with the JSF2.0 release, OcpSoft will be updating PF1.2.x for maintenance only, however, community participation is still welcome on all versions of the project.

You can now become powered-by-prettyfaces, or have your prettyfaces-powered site listed to build additional SEO page-rank. We want to know who is using our tool!

While it could potentially impact some applications functional behavior, the change is necessary in order to make progress and enable cool new features now and in the future! So, apologies for any trouble, but we’re sure that you’ll like what’s coming!

Big new feature in 2.0.3_RC1:

Integrated URL validation – Everyone should be afraid of user input, and parsing values from the URL is no different. But be not afraid! It is now possible to attach JSF validators to URL and Query parameters. This functionality parallels the new <f:pageParam> tag provided in JSF2, but also provides additional hooks into Validation error handling.

<url-mapping id="validate">
	<pattern value="/validate/#{validationBean.pathInput}">
		<validate param="0" validatorIds="validator1 validator2" 
			onError="#{validationBean.handle}" />
	</pattern>
	<query-param name="param1" validatorIds="validator2" onError="pretty:demo">
		#{validationBean.queryInput}
	</query-param>
	<view-id>/faces/validation/test.jsf</view-id>
</url-mapping>

As you can see, path parameters may now be validated with the <validate> element, and query parameters have a new “validatorIds” attribute. Any number of validatorIds may be attached to a given parameter. If validation fails, the system will send a 404 – Page Not Found response to the client.

If the default validation error handling is not enough, each validation may be provided with an optional “onError” attribute, which can be a “pretty:mappingId” (which issues a redirect to the page specified), or a #{jsfBean.handlerMethod} to allow complete control of the validation error. If the handler method returns null, or empty, the error is ignored and the lifecycle will continue. If the handler method returns a pretty:mappingId, PrettyFaces navigation will be invoked.

Validation processing follows a defined lifecycle:

PrettyFaces Validation Flow

May the power of pretty be with you.

The Presentation covers PrettyFaces basics, Search Engine Optimization, Rethinking Navigation, and Dynamic ViewIds:

PrettyFaces – Harness SEO, Improve User Experience, Ease Development J2EE is already the perfect solution for complex business/enterprise systems, and JSF2.x is the perfect chance to reach out to the consumer and small business market. JSF is easier to use than it’s ever been before, but small businesses have different needs than larger companies and corporations. PrettyFaces, however, is not just for small businesses; this session will present how it makes JSF accessible for anyone developing client-facing applications, addressing SEO optimization, and creating clean, consistent, intuitive client interactions on the web.

How PrettyFaces works:

The talk introduces you to URL rewriting, storing contextual information, and managing page configuration data with address and query parameters (resource identification, table pagination, data filters.) PrettyFaces’ centralized approach uses URLs to retain the state of pages, meaning less information must be stored in session and application scoped beans.

Rethinking navigation:

Navigation from the eye of the client. JSF supports page flows well, but managing simple transitions from one page to another can be complex.  Demonstrations of PrettyFaces integrated navigation, hyper-linking via Bijection and Components will show how developers gain increased control over all aspects of navigation out of the box, and how this is accomplished without extra configuration.

SEO:

You will be presented with concepts of how to improve client experience, confidence, and conversions through creating a consistent look and feel – the importance the browser URL plays an in establishing and trust through all client interactions.

Security & Usability:

The talk will discuss issues of security and usability. Security means restricting access and functionality; the client should be confident in their safety, yet never feel as if they are overly constrained. Examples show how PrettyFaces dynamic view identifiers allow extreme flexibility, increased security in abstracting resource locations, and will demonstrate how to create the appropriate experience in scenarios where users attempt to access restricted or unavailable resources.

About Lincoln:

Lincoln Baxter, III is a co-founder of OcpSoft, the author of PrettyFaces: SEO, Dynamic Parameters, Bookmarks, and Navigation for JSF / JSF2, and an individual member of the JSF2 Expert Group. When he is not swimming, running, or playing Ultimate Frisbee, Lincoln is focused on developing streamlined applications for the Agile and Scrum development methodologies.

]]> http://ocpsoft.com/prettyfaces/prettyfaces-hear-about-it-at-jsfsummit/feed/ 0 http://ocpsoft.com/prettyfaces/calling-all-prettyfaces-users/ http://ocpsoft.com/prettyfaces/calling-all-prettyfaces-users/#comments Sun, 30 Aug 2009 16:41:17 +0000 Lincoln http://ocpsoft.com/?p=70 Are you using PrettyFaces on a project you can share about?

Looking for real-world experiences:

• How has PrettyFaces helped you or your team?
• What would you change if you could (you can)?
• If you would like to share, show us your work of art!

Email to: lincoln@ocpsoft.com

Thank you!

PS – In addition: If you’d like to be added to our new “People using PrettyFaces” page, also send a logo and a short description of your product or company!

]]> http://ocpsoft.com/prettyfaces/calling-all-prettyfaces-users/feed/ 0