Criando um projeto JSF

Criando um projeto JSF com login e um CRUD usando Maven + Primefaces + Spring + Hibernate/JPA + PostgresSQL + Tomcat + Eclipse

Vamos criar uma aplicação sem muitos detalhes, mas futuramente farei um post para cada tecnologia e arquivos de configurações explicando-os detalhadamente. Como o post ficou muito grande, o projeto aqui está incompleto porém funcional, vamos deixar ele redondo e explicado até o final.

1º - Criando e configurando o projeto usando o maven no Eclipse.

        - Vai em File > New > Maven, marque a primeira opção (Create a simple project) e então click Next.
        - Vamos preencher os dados do Projeto vou utilizar LinuxAndJava como referência mas você pode dar o nome que você  quiser:
                - Group Id: br.com.blogspot.linuxandjava
                - Artifact Id: projecttest
                - Packaging: war
                - Name: Project Test
                - Preenchendo só esses dados ja é o suficiente. Então clique em Finish e o projeto é criado!
        - Adicione as dependencias no pom.xml :

        <!-- JSF --> <dependency> <groupId>org.glassfish</groupId> <artifactId>javax.faces</artifactId> <version>2.2.5</version> </dependency> <dependency> <groupId>javax.servlet</groupId> <artifactId>jstl</artifactId> <version>1.2</version> </dependency>

        - Vamos baixar essas dependencias: Botão direito > Run As > Maven Build
        - Vamos configurar o compilador para Java 1.8, Botão direito no projeto que foi criado Vai em properties > Java Compiler > Desmarque o         checkbox (Use compliance from execution environment....) e mude a versão do java no combobox (compiler complience level) de 1.5 para 1.8.
        - Ainda em properties vamos ativar a versão do JSF 2.2 no menu Project Facelets > JavaServer Faces e então marque o checkbox.
        - Ainda em Project Facelets mude a versão do Java para 1.8 novamente e mude o Dynamic Web Module para 3.1.
        - Adicione a dependencia abaixo do Primefaces no pom.xml :

        <!-- Primefaces --> <dependency> <groupId>org.primefaces</groupId> <artifactId>primefaces</artifactId> <version>5.1</version> </dependency>

- Configurando o web.xml:


 <?xml version="1.0" encoding="UTF-8"?> <web-app xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns="http://xmlns.jcp.org/xml/ns/javaee" xsi:schemaLocation="http://xmlns.jcp.org/xml/ns/javaee http://xmlns.jcp.org/xml/ns/javaee/web-app_3_1.xsd" version="3.1"> <display-name>projecttest</display-name> <welcome-file-list> <welcome-file>login.jsf</welcome-file> </welcome-file-list> <context-param> <param-name>javax.faces.PROJECT_STAGE</param-name> <param-value>Development</param-value> </context-param> <!-- Servlet --> <servlet> <servlet-name>Faces Servlet</servlet-name> <servlet-class>javax.faces.webapp.FacesServlet</servlet-class> <load-on-startup>5</load-on-startup> </servlet> <servlet-mapping> <servlet-name>Faces Servlet</servlet-name> <url-pattern>*.xhtml</url-pattern> </servlet-mapping> <servlet-mapping> <servlet-name>Faces Servlet</servlet-name> <url-pattern>*.jsf</url-pattern> </servlet-mapping> </web-app>

2º - Criando a base de dados e a primeira tabela para os usuários do sistema e biblioteca do Postgres:

- Como falei sem muitos detalhes por enquanto vamos usar o script abaixo para criar nossa base e usuário:

create database projecttest;

create table users (
  id bigserial,
  name varchar(150) not null,
  login varchar(150) not null,
  password varchar not null,
  constraint pk_usuario primary key (id)
);

- Vamos inseir um usuário na base manualmente somente para testes conforme o script abaixo:

insert into users (id,name,login,password) values(nextval('users_id_seq'),'Primeiro Usuário','user1','user1');

- Adicione a dependencia do postgres no pom.xml
     
<!-- PostgreSQL -->
<dependency>
<groupId>postgresql</groupId>
<artifactId>postgresql</artifactId>
<version>9.0-801.jdbc4</version>
</dependency>

3º - Configurando o Hibernate/JPA:

  - Adicione as dependencias no pom.xml e baixe as mesmas : 

<!-- Hibernate --> <dependency> <groupId>org.hibernate</groupId> <artifactId>hibernate-core</artifactId> <version>4.0.0.Final</version> </dependency> <dependency> <groupId>org.hibernate</groupId> <artifactId>hibernate-entitymanager</artifactId> <version>4.0.0.Final</version> </dependency> <dependency> <groupId>org.hibernate.javax.persistence</groupId> <artifactId>hibernate-jpa-2.0-api</artifactId> <version>1.0.1.Final</version> </dependency> <dependency> <groupId>org.hibernate.java-persistence</groupId> <artifactId>jpa-api</artifactId> <version>2.0-cr-1</version> </dependency>

  - Configurar o JPA no eclipse (Botão direito > properties > Project Facets, marque o JPA e mude para versão 2.0 no combobox ao lado)
- Vai aparecer um alerta de erro abaixo (Further configuration required), click nele e no combobox Type mude para Disable Library         Configuration.Clique em ok e ok novamente.
- Será criado u arquivo chamado persistence.xml em projecttest > JPA Content. Abra ele e cole o conteúdo abaixo:

        <?xml version="1.0" encoding="UTF-8"?> <persistence version="2.0" xmlns="http://java.sun.com/xml/ns/persistence" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://java.sun.com/xml/ns/persistence http://java.sun.com/xml/ns/persistence/persistence_2_0.xsd"> <persistence-unit name="projecttestPU"> <provider>org.hibernate.ejb.HibernatePersistence</provider> <!-- Informações do banco --> <properties> <property name="hibernate.dialect" value="org.hibernate.dialect.PostgreSQLDialect" /> <property name="hibernate.show_sql" value="true" /> <property name="hibernate.format_sql" value="true" /> </properties> </persistence-unit> </persistence>

4º - Configurando nosso Spring para gerenciar nossas transações:

  - Adicione as dependencias no pom.xml e baixe as mesmas (estou adicionando outras dependencias do Spring mas que só vamos utilizalas        futuramente, que ainda não será nesse post) :

<!-- Spring Controle de Transação -->
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-web</artifactId>
<version>${spring.version}</version>
</dependency>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-orm</artifactId>
<version>${spring.version}</version>
</dependency>
<dependency>
<groupId>commons-dbcp</groupId>
<artifactId>commons-dbcp</artifactId>
<version>1.2.2</version>

</dependency>

<!-- Spring Security -->
<dependency>
<groupId>org.springframework.security</groupId>
<artifactId>spring-security-core</artifactId>
<version>2.3.2.RELEASE</version>
</dependency>
<dependency>
<groupId>org.springframework.security</groupId>
<artifactId>spring-security-config</artifactId>
<version>2.3.2.RELEASE</version>
</dependency>
<dependency>
<groupId>org.springframework.security</groupId>
<artifactId>spring-security-web</artifactId>
<version>2.3.2.RELEASE</version>
</dependency>

<dependency>
<groupId>org.springframework.security</groupId>
<artifactId>spring-security-taglibs</artifactId>
<version>2.3.2.RELEASE</version>
</dependency>
<dependency>
<groupId>org.springframework.webflow</groupId>
<artifactId>spring-faces</artifactId>
<version>2.3.2.RELEASE</version>
</dependency>

  - Crie uma pasta chamada spring em projecttest > src > main > webapp > WEB-INF.
- Crie 3 arquivos dentro da pasta spring chamados (spring-context.xml, spring-security.xml e springsecurity.taglib.xml)
- Dentro do arquivo spring-context.xml coloque o seguinte conteúdo:

<?xml version="1.0" encoding="UTF-8"?>

<!-- Spring controle de trasações -->
<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:mvc="http://www.springframework.org/schema/mvc" 
xmlns:tx="http://www.springframework.org/schema/tx"
xsi:schemaLocation="http://www.springframework.org/schema/mvc 
          http://www.springframework.org/schema/mvc/spring-mvc-3.0.xsd
          http://www.springframework.org/schema/beans 
          http://www.springframework.org/schema/beans/spring-beans-3.0.xsd
          http://www.springframework.org/schema/context 
          http://www.springframework.org/schema/context/spring-context-3.0.xsd
          http://www.springframework.org/schema/tx 
          http://www.springframework.org/schema/tx/spring-tx-3.0.xsd">

<context:component-scan base-package="br.com.blogspot.linuxandjava" />

<!-- configurações da base -->
<bean id="pgSqlDataSource" class="org.apache.commons.dbcp.BasicDataSource">
<property name="driverClassName" value="org.postgresql.Driver" />

<property name="url" value="jdbc:postgresql://localhost:5432/projecttest" />
<property name="username" value="postgres" />
<property name="password" value="root" />

</bean>

<!-- gerenciamento de jpa pelo spring -->
<bean id="entityManagerFactory"
class="org.springframework.orm.jpa.LocalContainerEntityManagerFactoryBean">
<property name="dataSource" ref="pgSqlDataSource" />
<property name="jpaVendorAdapter">
<bean class="org.springframework.orm.jpa.vendor.HibernateJpaVendorAdapter" />
</property>
</bean>

<!-- gerenciamento da transação pelo spring -->
<bean id="transactionManager" class="org.springframework.orm.jpa.JpaTransactionManager">
<property name="entityManagerFactory" ref="entityManagerFactory" />
</bean>

<tx:annotation-driven />

</beans>

  - Deixe os outros arquivos em branco para usarmos futuramente.

        - Inserir o conteúdo abaixo no arquivo faces-config.xml que está em src > main > webapp > WEB-INF.

       <!-- Spring --> <application> <el-resolver>org.springframework.web.jsf.el.SpringBeanFacesELResolver</el-resolver> </application> - Inserir o conteúdo abaixo no arquivo web.xml: <!-- Spring --> <context-param> <param-name>contextConfigLocation</param-name> <param-value> /WEB-INF/spring/spring-context.xml /WEB-INF/spring/spring-security.xml </param-value> </context-param> <listener> <listener-class>org.springframework.web.context.ContextLoaderListener</listener-class> </listener> <!-- Spring Controle de transação --> <filter> <filter-name>openEntityManagerInViewFilter</filter-name> <filter-class>org.springframework.orm.jpa.support.OpenEntityManagerInViewFilter</filter-class> </filter> <filter-mapping> <filter-name>openEntityManagerInViewFilter</filter-name> <url-pattern>/*</url-pattern> </filter-mapping> <!-- Spring Security --> <filter> <filter-name>springSecurityFilterChain</filter-name> <filter-class>org.springframework.web.filter.DelegatingFilterProxy</filter-class> </filter> <filter-mapping> <filter-name>springSecurityFilterChain</filter-name> <url-pattern>/*</url-pattern> </filter-mapping> <context-param> <param-name>javax.faces.FACELETS_LIBRARIES</param-name> <param-value>/WEB-INF/spring/springsecurity.taglib.xml</param-value> </context-param>
 

5º - Criando nossa parte back end do Java desde Managed Bean até o nosso Dao:

        - Criando nossa entidade

- Crie o pacote br.com.blogspot.linuxandjava.entity
- Dentro do pacote entity crie entidade GenericEntity com o conteudo a seguir:

  package br.com.blogspot.linuxandjava.entity;

  public abstract class GenericEntity implements Cloneable {

  public abstract Long getId();

  public abstract void setId(Long id);

  public GenericEntity clone() {

  try {
return (GenericEntity) super.clone();
} catch (CloneNotSupportedException e) {
e.printStackTrace();
}

  return null;

  }

  /** Get's and Set's */

  /** hashCode and equals */
@Override
public int hashCode() {
final int prime = 31;
int result = 1;
result = prime * result;
return result;
}

  @Override
public boolean equals(Object obj) {
if (this == obj) {
return true;
}
if (obj == null) {
return false;
}
if (getClass() != obj.getClass()) {
return false;
}
return true;
}

  }

  - Dentro do pacote entity crie entidade Users com o conteudo a seguir:

 
package br.com.blogspot.linuxandjava.entity;

  import java.io.Serializable;

  import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;
import javax.persistence.SequenceGenerator;
import javax.persistence.Table;

  /**
* @author LinuxAndJava
* 
*/
@Entity
@Table(name = "users")
public class Users extends GenericEntity implements Serializable {

  private static final long serialVersionUID = 1L;

  @Id
@Column(unique = true, nullable = false)
@SequenceGenerator(name = "users_seq", sequenceName = "users_id_seq", allocationSize = 1)
@GeneratedValue(strategy = GenerationType.SEQUENCE, generator = "users_seq")
private Long id;

  private String name;

  private String login;

  private String password;

  /** Get's and Set's */

  @Override
public Long getId() {
return id;
}

  @Override
public void setId(Long id) {
this.id = id;
}

  public String getName() {
return name;
}

  public void setName(String name) {
this.name = name;
}

  public String getLogin() 
public String getPassword() {
return password;
}

  public void setPassword(String password) {
this.password = password;
}

  /** hashCode and equals */

  @Override
public int hashCode() {
final int prime = 31;
int result = super.hashCode();
result = prime * result + ((id == null) ? 0 : id.hashCode());
result = prime * result + ((login == null) ? 0 : login.hashCode());
result = prime * result + ((name == null) ? 0 : name.hashCode());
result = prime * result
+ ((password == null) ? 0 : password.hashCode());
return result;
}

  @Override
public boolean equals(Object obj) {
if (this == obj) {
return true;
}
if (!super.equals(obj)) {
return false;
}
if (getClass() != obj.getClass()) {
return false;
}
Users other = (Users) obj;
if (id == null) {
if (other.id != null) {
return false;
}
} else if (!id.equals(other.id)) {
return false;
}
if (login == null) {
if (other.login != null) {
return false;
}
} else if (!login.equals(other.login)) {
return false;
}
if (name == null) {
if (other.name != null) {
return false;
}
} else if (!name.equals(other.name)) {
return false;
}
if (password == null) {
if (other.password != null) {
return false;
}
} else if (!password.equals(other.password)) {
return false;
}
return true;
}

  }{
return login;
}

  public void setLogin(String login) {
this.login = login;
}

  public String getPassword() {
return password;
}

  public void setPassword(String password) {
this.password = password;
}

  /** hashCode and equals */

  @Override
public int hashCode() {
final int prime = 31;
int result = super.hashCode();
result = prime * result + ((id == null) ? 0 : id.hashCode());
result = prime * result + ((login == null) ? 0 : login.hashCode());
result = prime * result + ((name == null) ? 0 : name.hashCode());
result = prime * result
+ ((password == null) ? 0 : password.hashCode());
return result;
}

  @Override
public boolean equals(Object obj) {
if (this == obj) {
return true;
}
if (!super.equals(obj)) {
return false;
}
if (getClass() != obj.getClass()) {
return false;
}
Users other = (Users) obj;
if (id == null) {
if (other.id != null) {
return false;
}
} else if (!id.equals(other.id)) {
return false;
}
if (login == null) {
if (other.login != null) {
return false;
}
} else if (!login.equals(other.login)) {
return false;
}
if (name == null) {
if (other.name != null) {
return false;
}
} else if (!name.equals(other.name)) {
return false;
}
if (password == null) {
if (other.password != null) {
return false;
}
} else if (!password.equals(other.password)) {
return false;
}
return true;
}

  }



  - Configure a classe Users colocando as seguintes linhas abaixo de "<provider>org.hibernate.ejb.HibernatePersistence</provider>" :

  <!-- Entidades -->
<class>br.com.blogspot.linuxandjava.entity.Users</class>
<!-- Fim Entidades -->


  - Criando nossos Daos

        - Crie o pacote dao no mesmo nivel de entity ou seja br.com.blogspot.linuxandjava.dao
- Criando nosso genéric dao
- Crie a interface GenericDaoInterface conforme o conteúdo abaixo:

package br.com.blogspot.linuxandjava.dao;

import java.util.List;

import javax.persistence.criteria.CriteriaBuilder;
import javax.persistence.criteria.CriteriaQuery;

import br.com.blogspot.linuxandjava.entity.GenericEntity;

public interface GenericDaoInterface<T extends GenericEntity> {

public T save(T entity);

public void remove(Class<T> clazz, Long id);

public T findById(Class<T> clazz, Long id);

public List<T> findAll(Class<T> clazz);

public List<T> find(CriteriaQuery<T> criteriaQuery, int firstResult,
int maxResult);

public Long countAll(Class<T> clazz);

public CriteriaBuilder getCriteriaBuilder();

public List<T> find(String qlString);

}

- Crie a classe GenericDao conforme o conteúdo abaixo:

package br.com.blogspot.linuxandjava.dao;

import java.io.Serializable;
import java.util.List;

import javax.persistence.EntityManager;
import javax.persistence.PersistenceContext;
import javax.persistence.criteria.CriteriaBuilder;
import javax.persistence.criteria.CriteriaQuery;

import org.springframework.stereotype.Repository;
import org.springframework.transaction.annotation.Transactional;

import br.com.blogspot.linuxandjava.entity.GenericEntity;

@Repository
public class GenericDao<T extends GenericEntity> implements
GenericDaoInterface<T>, Serializable {

private static final long serialVersionUID = 1L;

public static final String MANAGED_PROP_NAME = "#{genericDao}";

@PersistenceContext
private EntityManager entityManager;

@Override
@Transactional
public T save(T entity) {
try {

if (entity.getId() != null || entity.getId() == 0L) {
entity = entityManager.merge(entity);
} else {
entityManager.persist(entity);
}

} catch (Exception e) {
e.printStackTrace();
}
return entity;
}

@Override
@Transactional
public void remove(Class<T> clazz, Long id) {
try {
entityManager.remove(entityManager.getReference(clazz, id));
} catch (Exception e) {
e.printStackTrace();
}
}

@Override
@Transactional
public T findById(Class<T> clazz, Long id) {

try {
return entityManager.find(clazz, id);
} catch (Exception e) {
e.printStackTrace();
}

return null;
}

@Override
@SuppressWarnings("unchecked")
@Transactional
public List<T> findAll(Class<T> clazz) {

try {

return entityManager.createQuery("from " + clazz.getSimpleName())
.getResultList();

} catch (Exception e) {
e.printStackTrace();
}

return null;

}

@Override
@Transactional
public List<T> find(CriteriaQuery<T> criteriaQuery, int firstResult,
int maxResult) {
return entityManager.createQuery(criteriaQuery)//
.setFirstResult(firstResult)//
.setMaxResults(maxResult)//
.getResultList();
}

@Override
@SuppressWarnings("unchecked")
@Transactional
public List<T> find(String qlString) {

try {

return entityManager.createQuery(qlString).getResultList();

} catch (Exception e) {
e.printStackTrace();
}

return null;

}

public Long countAll(Class<T> clazz) {
CriteriaBuilder criteriaBuilder = getCriteriaBuilder();
CriteriaQuery<Long> criteriaQuery = criteriaBuilder
.createQuery(Long.class);
criteriaQuery.select(criteriaBuilder.count(criteriaQuery.from(clazz)));
return entityManager.createQuery(criteriaQuery).getSingleResult();
}

@Override
public CriteriaBuilder getCriteriaBuilder() {
return entityManager.getCriteriaBuilder();
}

}

- Crie a interface UsersDaoInterface conforme o conteúdo abaixo:

package br.com.blogspot.linuxandjava.dao;

import br.com.blogspot.linuxandjava.entity.Users;

public interface UsersDaoInterface extends GenericDaoInterface<Users> {

}

- Crie a classe UsersDao conforme o conteúdo abaixo:

package br.com.blogspot.linuxandjava.dao;

import org.springframework.stereotype.Repository;

import br.com.blogspot.linuxandjava.entity.Users;

@Repository
public class UsersDao extends GenericDao<Users> implements UsersDaoInterface {

private static final long serialVersionUID = 1L;

public static final String MANAGED_PROP_NAME = "#{usersDao}";

}

- Criando o ManagedBean

- Crie o pacote mb no mesmo nivel de entity
        - Dentro do pacote MB criar a Classe GenericMB com o conteúdo a seguir:

package br.com.blogspot.linuxandjava.mb;

import java.io.Serializable;
import java.lang.reflect.ParameterizedType;
import java.util.List;

import javax.annotation.PostConstruct;
import javax.faces.bean.ManagedProperty;
import javax.faces.event.ActionEvent;

import br.com.blogspot.linuxandjava.dao.GenericDao;
import br.com.blogspot.linuxandjava.dao.GenericDaoInterface;
import br.com.blogspot.linuxandjava.entity.GenericEntity;

public abstract class GenericMB<T extends GenericEntity> implements
Serializable {

private static final long serialVersionUID = 1L;

private T bean;

private T viewBean;

private T searchBean;

private List<T> listBean;

private Class<T> clazz;

@ManagedProperty(value = GenericDao.MANAGED_PROP_NAME)
private GenericDaoInterface<T> dao;

@PostConstruct
public void init() {
clazz = getClazz();
initBean();
}

public void save() {
save(this.bean, true);
}

protected void save(T bean, boolean showCallBackMsg) {

try {

dao.save(bean);

initBean();
cleanListBean();

} catch (Exception e) {
e.printStackTrace();
}

}

public void delete(ActionEvent actionEvent) throws Exception {

try {

dao.remove(clazz, bean.getId());

initBean();
cleanListBean();

} catch (Exception e) {
e.printStackTrace();
}

}

public void cancel() throws Exception {
initBean();
}

public List<T> getListBean() {

if (listBean != null) {
return listBean;
}

return listBean;

}

protected void cleanListBean() {
listBean = null;
}

public void setEditBean(T bean) {
setBean(bean);
}

public void setDeleteBean(T bean) {
setBean(bean);
}

/** abstracts methods */

public abstract void initBean();

/** Get's and Set's */

public void setDao(GenericDaoInterface<T> dao) {
this.dao = dao;
}

public T getBean() {
return bean;
}

@SuppressWarnings("unchecked")
public void setBean(T bean) {
this.bean = (T) bean.clone();
}

public void setViewBean(T viewBean) {
this.viewBean = viewBean;
}

public T getViewBean() {
return viewBean;
}

public void setSearchBean(T searchBean) {
this.searchBean = searchBean;
}

public T getSearchBean() {
return searchBean;
}

@SuppressWarnings("unchecked")
private Class<T> getClazz() {
return (Class<T>) ((ParameterizedType) getClass()
.getGenericSuperclass()).getActualTypeArguments()[0];
}

}


- Dentro do pacote MB criar a Classe UsersMB com o conteúdo a seguir:

package br.com.blogspot.linuxandjava.mb;

import javax.faces.bean.ManagedBean;
import javax.faces.bean.ManagedProperty;
import javax.faces.bean.ViewScoped;

import br.com.blogspot.linuxandjava.dao.UsersDao;
import br.com.blogspot.linuxandjava.dao.UsersDaoInterface;
import br.com.blogspot.linuxandjava.entity.Users;

@ManagedBean
@ViewScoped
public class UsersMB extends GenericMB<Users> {

private static final long serialVersionUID = 1L;

private String password;

private String passwordRepeat;

@ManagedProperty(value = UsersDao.MANAGED_PROP_NAME)
private UsersDaoInterface usersDao;

@Override
public void initBean() {
setBean(new Users());
setSearchBean(mountSearchBean());
}

private Users mountSearchBean() {
Users users = new Users();
return users;
}

@Override
public void save() {

if (!password.equals(passwordRepeat)) {
return;
}

getBean().setPassword(password);

super.save();

clearFields();

}

@Override
public void setViewBean(Users viewBean) {
super.setViewBean(usersDao.findById(Users.class, viewBean.getId()));
}

@Override
public void setEditBean(Users users) {

users = usersDao.findById(Users.class, users.getId());

password = users.getPassword();
passwordRepeat = users.getPassword();

super.setEditBean(users);

}

@Override
public void cancel() throws Exception {
super.cancel();
clearFields();
}

private void clearFields() {
password = null;
passwordRepeat = null;
}

/** Get's and Set's */

public String getPassword() {
return password;
}

public void setPassword(String password) {
this.password = password;
}

public String getPasswordRepeat() {
return passwordRepeat;
}

public void setPasswordRepeat(String passwordRepeat) {
this.passwordRepeat = passwordRepeat;
}

public void setUsersDao(UsersDaoInterface usersDao) {
this.usersDao = usersDao;
}

}

- Dentro do pacote MB criar a Classe LoginMB com o conteúdo a seguir:

                package br.com.blogspot.linuxandjava.mb;

import java.io.Serializable;
import java.util.List;

import javax.faces.bean.ManagedBean;
import javax.faces.bean.ManagedProperty;
import javax.faces.bean.ViewScoped;

import org.springframework.security.core.AuthenticationException;

import br.com.blogspot.linuxandjava.dao.UsersDao;
import br.com.blogspot.linuxandjava.dao.UsersDaoInterface;
import br.com.blogspot.linuxandjava.entity.Users;

@ManagedBean
@ViewScoped
public class LoginMB implements Serializable {

private static final long serialVersionUID = 1L;

private String login = "";
private String password = "";

@ManagedProperty(value = UsersDao.MANAGED_PROP_NAME)
private UsersDaoInterface usersDao;

public String doLogin() {

try {

Users users = new Users();
users.setLogin(login);
users.setPassword(password);

List<Users> usersList = usersDao.find(" from Users where login = '"
+ login + "' and password = '" + password + "'");

if (usersList != null && usersList.size() != 0) {
return "doLogin";
}

} catch (AuthenticationException e) {
e.printStackTrace();
}

return null;
}

public void setUsersDao(UsersDaoInterface usuarioDao) {
this.usersDao = usuarioDao;
}

public String getLogin() {
return login;
}

public void setLogin(String login) {
this.login = login;
}

public String getPassword() {
return password;
}

public void setPassword(String password) {
this.password = password;
}

}


6º - Criando os .xhml's:

- Criar a primeira pagina xhtml chamada login.xhtml na pasta webapp (src > main > webapp) coforme foi mapeada no web.xml.
- Copie o conteudo abaixo e cole no arquivo criado:

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd">
<html xmlns="http://www.w3.org/1999/xhtml"
xmlns:h="http://java.sun.com/jsf/html"
xmlns:f="http://java.sun.com/jsf/core"
xmlns:c="http://java.sun.com/jsp/jstl/core"
xmlns:ui="http://java.sun.com/jsf/facelets"
xmlns:p="http://primefaces.org/ui">

<h:head> 
    Welcome to Login page
   </h:head>

<h:body>

<p:layout id="container" fullPage="true">

<p:layoutUnit id="content" position="center">

<h:form id="formLoginID">

<p:focus context="formLoginID" />

<div align="center">

<h:panelGrid columns="1">

<h:outputText value="User:" />
<p:inputText value="#{loginMB.login}" size="30" />

<h:outputText value="Password" />
<p:password value="#{loginMB.password}" size="30" />

<p:commandButton value="Entrar" action="#{loginMB.doLogin}"
update="@form" />

</h:panelGrid>

</div>

</h:form>

</p:layoutUnit>

</p:layout>

</h:body>

</html>

- Criar um novo folder chamado pages em webapp
- Criar um arquivo dentro de pages chamado index.xhtml com o conteúdo a seguir:

        <?xml version="1.0" encoding="UTF-8"?> <!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd"> <html xmlns="http://www.w3.org/1999/xhtml" xmlns:h="http://java.sun.com/jsf/html" xmlns:f="http://java.sun.com/jsf/core" xmlns:c="http://java.sun.com/jsp/jstl/core" xmlns:ui="http://java.sun.com/jsf/facelets" xmlns:p="http://primefaces.org/ui"> <h:head> Hello world! </h:head> <h:body> Success :) </h:body> </html>

- Mapear a chamada da view index.xhtml atravéz do login em faces-config.xml colocando o conteúdo abaixo:

       <navigation-rule> <from-view-id>/login.xhtml</from-view-id> <navigation-case> <from-outcome>doLogin</from-outcome> <to-view-id>/pages/index.jsf</to-view-id> <redirect /> </navigation-case> </navigation-rule>

- Rode o projeto (Botão direito no projeto > Rus As > Run on Server) e veja se está tudo ok.
 - Efetue o login com o usuario(user1) senha (user1) criados diretamente na base.


É isso ai! até o próximo post com a continuação desse projeto ;)