06. HelloObjectify - AntonioDiaz/examples.spring.mvc GitHub Wiki

public class RegisterEntities {	
	public void init() {
		ObjectifyService.register(Customer.class);
	}
}

import java.util.ArrayList;
import java.util.List;

import com.googlecode.objectify.Ref;
import com.googlecode.objectify.annotation.Entity;
import com.googlecode.objectify.annotation.Id;
import com.googlecode.objectify.annotation.Index;

import org.apache.commons.lang3.builder.ToStringBuilder;

@Entity
public class Customer {

	@Id
	private Long id;
	@Index
	private String name;
	@Index
	private String surname01;
	@Index
	private String surname02;

	private List<Ref<Order>> orders = new ArrayList<Ref<Order>>();

	/* getters and setters. */
	@Override
	public String toString() {
		return ToStringBuilder.reflectionToString(this);
	}
}

package com.dao;
public interface GenericDAO<T> {
	public void create(T item) throws Exception;
	public boolean update(T item) throws Exception;
	public boolean remove(T item) throws Exception;	
}

package com.dao;

import java.util.List;
import com.domain.Customer;

public interface CustomerDAO extends GenericDAO<Customer>{
	public List<Customer> findAllCustomers();
	public List<Customer> findCustomers(Customer customer);
}

package com.dao;

import static com.googlecode.objectify.ObjectifyService.ofy;
import java.util.ArrayList;
import java.util.List;
import org.apache.commons.lang3.StringUtils;
import org.springframework.stereotype.Repository;
import com.domain.Customer;
import com.googlecode.objectify.Key;
import com.googlecode.objectify.cmd.Query;

@Repository
public class CustomerDAOImpl implements CustomerDAO {

	@Override
	public void create(Customer customer) throws Exception {
		ofy().save().entity(customer).now();
	}

	@Override
	public boolean update(Customer customer) throws Exception {
		boolean updateResult;
		if (customer == null || customer.getId() == null) {
			updateResult = false;
		} else {
			Customer c = ofy().load().type(Customer.class).id(customer.getId()).now();
			if (c != null) {
				ofy().save().entity(customer).now();
				updateResult = true;
			} else {
				updateResult = false;
			}
		}
		return updateResult;
	}

	@Override
	public boolean remove(Customer customer) throws Exception {
		ofy().delete().entity(customer).now();
		return true;
	}

	@Override
	public List<Customer> findAllCustomers() {
		Query<Customer> query = ofy().load().type(Customer.class);
		return query.order("name").list();		
	}

	@Override
	public List<Customer> findCustomers(Customer customer) {
		Query<Customer> query = ofy().load().type(Customer.class);
		List<Customer> returnList = new ArrayList<Customer>();
		if (customer.getId()!=null) {
			Customer c = ofy().load().key(Key.create(Customer.class, customer.getId())).now();
			if (c!=null) {
				returnList.add(c);
			}
		} else {
			if (StringUtils.isNotBlank(customer.getName())) {
				query = query.filter("name", customer.getName());
			}
			if (StringUtils.isNotBlank(customer.getSurname01())) {
				query = query.filter("surname01", customer.getSurname01());
			}
			if (StringUtils.isNotBlank(customer.getSurname02())) {
				query = query.filter("surname02", customer.getSurname02());
			}
			returnList = query.order("name").list();
		}
		return returnList;
	}
}

package com.services;
import java.util.List;
import com.domain.Customer;
public interface CustomerManager {
	public List<Customer> customers();	
	public List<Customer> customers(Customer customer);	
	public void add(Customer customer) throws Exception;	
	public boolean remove(Customer customer) throws Exception;	
	public boolean update(Customer customer) throws Exception;
}

package com.services;

import java.util.List;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import com.dao.CustomerDAO;
import com.domain.Customer;

@Service ("customerManager")
public class CustomerManagerImpl implements CustomerManager {

	@Autowired CustomerDAO dao;
	
	@Override
	public List<Customer> customers() {		
		return dao.findAllCustomers();
	}

	@Override
	public List<Customer> customers(Customer customer) {
		return dao.findCustomers(customer);
	}
	@Override
	public void add(Customer customer) throws Exception{
		dao.create(customer);		
	}
	...
}

package com.controllers;

import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import org.apache.log4j.Logger;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Controller;
import org.springframework.ui.ModelMap;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.ResponseBody;
import com.domain.Customer;
import com.domain.Order;
import com.googlecode.objectify.Ref;
import com.services.CustomerManager;

@Controller
public class MyController {

	private static final Logger logger = Logger.getLogger(MyController.class);
	
	@Autowired
	CustomerManager customerManager;

	@RequestMapping(value = {"/customersList","/"}, method = RequestMethod.GET)
	public String customerList(ModelMap modelMap) {
		modelMap.addAttribute("customersList", customerManager.customers());
		return "customers";
	}	
	
	@RequestMapping(value = "/doSearch")
	public @ResponseBody List<Map<String, Object>> doSearch(
			@RequestParam(value = "id", required = false, defaultValue = "") Long id,
			@RequestParam(value = "name", required = false, defaultValue = "") String name,
			@RequestParam(value = "surname01", required = false, defaultValue = "") String surname01,
			@RequestParam(value = "surname02", required = false, defaultValue = "") String surname02) {
		logger.debug("searching customers");
		Customer customer = new Customer();
		customer.setId(id);
		customer.setName(name);
		customer.setSurname01(surname01);
		customer.setSurname02(surname02);
		List<Customer> customers = customerManager.customers(customer);
		
		List<Map<String, Object>> list = new ArrayList<Map<String, Object>>();
		for (Customer c : customers) {
			Map<String, Object> data = new HashMap<String, Object>();
			data.put("id", c.getId());
			data.put("name", c.getName());
			data.put("surname01", c.getSurname01());			
			data.put("surname02", c.getSurname02());
			list.add(data);
		}		
		return list;
	}
	
	@RequestMapping(value="/viewOrders")
	public @ResponseBody List<Order> viewOrders(@RequestParam(value="idCustomer", required=true) Long idCustomer){
		logger.debug("idCustomer " + idCustomer);
		List<Order> orders = new ArrayList<Order>();
		Customer customer = new Customer();
		customer.setId(idCustomer);
		customer = customerManager.customers(customer).get(0);
		for (Ref<Order> myRef : customer.getOrders()) {
			orders.add(myRef.get());
		}
		return orders;
	}
}