In Parancoe the DAOs are not classes, just interfaces, without an explicit implementation. For example, for defining the DAO for the Person entity, you need to write:

package org.parancoe.example.dao;

import org.parancoe.example.po.Person;
import org.parancoe.persistence.dao.generic.Dao;
import org.parancoe.persistence.dao.generic.GenericDao;

@Dao(entity=Person.class)
public interface PersonDao extends GenericDao<Person, Long> {
}
                    

The generic parameters of the GenericDao interface are the type of the persistent entity, and the type of its identifier.

You don't have to write an implementation of this interface. The implementation will be automatically added at runtime through Spring AOP. The current implementation provides the following methods to each DAO:

T read(PK id);
T get(PK id);
void create(T transientObject);
void store(T transientObject);
void delete(T persistentObject);
List<T> findAll();
List<T> searchByCriteria(Criterion... criterion);
List<T> searchByCriteria(DetachedCriteria criteria);
List<T> searchByCriteria(DetachedCriteria criteria, int firstResult, int maxResults);
Page<T> searchPaginatedByCriteria(int page, int pageSize, Criterion... criterion);
Page<T> searchPaginatedByCriteria(int page, int pageSize, DetachedCriteria criteria);
int deleteAll();
long count();    
long countByCriteria(DetachedCriteria criteria);
                

Note that even these methods are parametrized with the type of the entity ( T) and the type of the entity identifier ( PK). So, for example, the findAll method of the DAO of the Person entity doesn't return a generic List<Object>, but it can return a more usefull type-checked List<Person>.

The DAOs are auto-discovered using the following tag in your Spring configuration (already included in the configuration produced by the Parancoe Web Archetype):

    <parancoe:define-daos basePackage="org.parancoe.example.dao"/>

                

So the only thing you need to do is to add the DAO interfaces classes in the correct package. No per-DAO configuration is needed.

To use a DAO you simply need to get it from the Spring application context. You could of course retrieve it by name from the context, using its unqualified name. For example you could retrieve the PersonDao throught the "personDao" name. But the easiest way for obtaining a reference to a DAO is to auto-wire it in a Spring managed bean.

For example, for using the PersonDao in a controller of your application:

package org.parancoe.example.controllers;

import org.parancoe.example.dao.PersonDao;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Controller;
import org.springframework.ui.Model;
import org.springframework.web.bind.annotation.RequestMapping;

@Controller
@RequestMapping("/people/*.html")
public class PeopleController {

                        @Autowired
    private PersonDao personDao;
                        

    @RequestMapping
    public String list(Model model) {
        model.addAttribute("people",
                        personDao.findAll());
        return "people/list";
    }
}
                    

For example, you need to find all people with first name equals to "John". Add to the interface the following method:

@Dao(entity=Person.class)
public interface PersonDao extends GenericDao<Person, Long> {
  List<Person> findByFirstName(String firstName);
}
                

If the finder needs to compare on more fields, simply list them in the method name separated by the “And” keyword:

@Dao(entity=Person.class)
public interface PersonDao extends GenericDao<Person, Long> {
  List<Person> findByFirstName(String firstName);
  List<Person> findByFirstNameAndLastNameAndBirthDate(
      String firstName, String lastName, Date birthDate);
}
                

If you need to order (ascending) the results, declare a method as the following:

@Dao(entity=Person.class)
public interface PersonDao extends GenericDao<Person, Long> {
  List<Person> findByBirthDateOrderByLastName(Date birthDate);
}
                

Again, If you need to order on more than one field, list the fields you need:

List<Person> findByBirthDateOrderByLastNameAndFirstName(Date birthDate);
                

If you don’t want to filter by equality, but the result must contains all records, omit the list of fields:

List<Person> findByOrderByLastNameAndFirstName();
                

Define the finder method returning the entity type, not a List:

Person findByFirstNameAndLastName(String firstName, String lastName);
                

If the query will produce more than one result, only the first one in the list will be returned. If the query will produce no results, the method will return null.

You can write an JPA-QL/HQL query and add a method in the DAO interface that will execute it when invoked. Declare the method as you like in the DAO interface, and declare the query as a named query in the DAO’s entity. The name of the query must be <entityName>.methodName. The method parameters are passed in the same order as values for the query parameters. For example:

@Dao(entity=Person.class)
public interface PersonDao extends GenericDao<Person, Long> {
  List<Person> findByPartialUncasedLastName(String partialLastName);
}
                

@Entity()
@NamedQueries({
  @NamedQuery(
    name="Person.findByPartialUncasedLastName",
    query="from Person p where lower(p.lastName) like lower(?) order by p.lastName")
})
public class Person extends EntityBase {
  // ...
}
                

Now You can invoke it:

List <Person> people = dao.findByPartialUncasedLastName("B%");
                

You can annotate the finder method parameters with the @FirstResult and @MaxResults annotations. For example:

@Dao(entity=Person.class)
public interface PersonDao extends GenericDao<Person, Long> {
  List<Person> findByLastName(String lastName,
                              @FirstResult int firstResult,
                              @MaxResults int maxResults);
}
                

The type of the annotate parameter must be int. You can apply this technique to finder methods associated to named queries, without the need to modify the query. For example:

@Dao(entity=Person.class)
public interface PersonDao extends GenericDao<Person, Long> {
  List<Person> findByPartialUncasedLastName(String partialLastName,
                                            @FirstResult int firstResult,
                                            @MaxResults maxResults);
}
                

@Entity()
@NamedQueries({
  @NamedQuery(
    name="Person.findByPartialUncasedLastName",
    query="from Person p where lower(p.lastName) like lower(?) order by p.lastName")
})
public class Person extends EntityBase {
  // ...
}
                

If there are situations in which you don’t want to limit the number of records, you can pass a negative value for the maxRecords parameter:

List<Person> people = dao.findByPartialUncasedLastName("B%", 0, -1);
                

It will return all records, from the first (0) to the end.

In totally dynamic finders you can choose the type of the comparison applied to each parameter using the @Compare annotation. For example:

@Dao(entity=Person.class)
public interface PersonDao extends GenericDao<Person, Long> {
  List<Person> findByLastName(
                 @Compare(CompareType.ILIKE) String lastName);
}
                

The supported comparison strategies are: