من یک مثال کامل میزنم براتون (با فرض اینکه از هایبرنت استفاده میکنید) تا با ساختار کلیش آشنا بشید. قبلش اینجارم (http://barnamenevis.org/showthread.php?493446-%D8%A7%DB%8C%D9%86-%D9%81%D8%A7%DB%8C%D9%84-JSON-%DA%A9%D9%87-%D8%A8%D8%A7-%D8%A7%D8%B3%D9%BE%D8%B1%DB%8C%D9%86%DA%AF-%D9%88-%DA%A9%D8%AA%D8%A7%D8%A8%D8%AE%D9%88%D9%86%D9%87-%D9%87%D8%A7%DB%8C-%D9%85%D8%B1%D8%A8%D9%88%D8%B7-%D8%A8%D9%87-REST-%D9%85%DB%8C%D8%B4%D9%87-%D8%AA%D9%88%D9%84%DB%8C%D8%AF%D8%B4-%DA%A9%D8%B1%D8%AF%D8%8C-%DA%A9%D8%AC%D8%A7-%D9%85%DB%8C%D8%B1%D9%87%D8%9F) ببینید.
البته نمیشه توی یک مثال همه چیزو توضیح داد. من فرض میکنم که شما با هایبرنت و spring transaction و در کل با ساختار spring آشنا هستید. درغیر اینصورت این مثال شاید بیشتر باعث سردرگمیتون بشه.
فرض کنیم میخوایم سایتی بنویسیم که مثلا لیست محصولات یک کارخونه رو باهاش مدیریت کنیم (CRUD).
یک کلاس Product میشه تعریف کرد به این شکل :
package test.model.entity;
import javax.persistence.*;
import java.util.Date;
@Table
@Entity
public class Product extends BaseEntity {
@Transient
private static final long serialVersionUID = 2445074974681854243L;
private String name;
private Date productionDate;
private float price;
public Product() {
}
public Product(String name, Date productionDate, float price) {
this.name = name;
this.productionDate = productionDate;
this.price = price;
}
@Column(nullable = false, unique = true)
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
@Temporal(TemporalType.TIMESTAMP)
@Column(nullable = false)
public Date getProductionDate() {
return productionDate;
}
public void setProductionDate(Date productionDate) {
this.productionDate = productionDate;
}
@Column(nullable = false)
public float getPrice() {
return price;
}
public void setPrice(float price) {
this.price = price;
}
}
و این هم BaseEntity :
package test.model.entity;
import javax.persistence.*;
import java.io.Serializable;
import java.util.Objects;
@MappedSuperclass
public class BaseEntity implements Serializable {
@Transient
private static final long serialVersionUID = -3904432509090573372L;
private long id;
@Id
@GeneratedValue(strategy = GenerationType.AUTO)
@Column(unique = true, nullable = false)
public long getId() {
return id;
}
public void setId(long id) {
this.id = id;
}
@Override
public int hashCode() {
return Objects.hashCode(id);
}
@Override
public boolean equals(Object obj) {
return this == obj || obj != null && obj instanceof BaseEntity && Objects.equals(id, ((BaseEntity) obj).getId());
}
}
تا اینجا entity هارو مشخص کردیم. در ضمن میشد BaseEntity رو نسازیم و همه چیو میبردیم تو خود Product، اما زمانی که تعداد entity ها بره بالا اینجوری کار راحتتر میشه برامون.
حالا باید بریم سراغ نوشتن CRUD برای entity مون، که من repository pattern رو برای اینکار انتخاب کردم (شما میتونید DAO بنویسید).
اینترفس IRepository :
package test.model.repository;
import test.model.entity.BaseEntity;
import java.io.Serializable;
import java.util.Collection;
public interface IRepository<T extends BaseEntity> {
Serializable save(T entity);
void update(T entity);
T get(long id);
Collection<T> loadAll();
void delete(T entity);
}
برای Product هم یک repository تعریف میکنیم و متدهای دلخواه دیگه ای هم توش تعریف میکنیم، مثلا :
package test.model.repository;
import test.model.entity.Product;
public interface IProductRepository extends IRepository<Product> {
boolean productExistsByName(String name);
Product findByName(String name);
}
بسته به انتیتی فریم ورکی که استفاده میکنیم (اینجا هایبرنت) پیاده سازی برای IRepository رو انجام میدیم. کلاسی به اسم HibernateRepository تعریف میکنیم که اعمال CRUD رو به صورت generic پیاده سازی کنه :
package test.model.repository;
import org.hibernate.SessionFactory;
import org.springframework.beans.factory.annotation.Autow ired;
import org.springframework.orm.hibernate4.support.Hiberna teDaoSupport;
import org.springframework.stereotype.Repository;
import test.model.entity.BaseEntity;
import java.io.Serializable;
import java.util.Collection;
@Repository("hibernateRepository")
public class HibernateRepository<T extends BaseEntity> extends HibernateDaoSupport implements IRepository<T> {
private Class<T> entityClass;
@Autowired
public HibernateRepository(SessionFactory sessionFactory) {
super.setSessionFactory(sessionFactory);
}
public Class<T> getEntityClass() {
return entityClass;
}
public void setEntityClass(Class<T> entityClass) {
this.entityClass = entityClass;
}
@Override
public Serializable save(T entity) {
return getHibernateTemplate().save(entity);
}
@Override
public void update(T entity) {
getHibernateTemplate().update(entity);
}
@Override
public T get(long id) {
return getHibernateTemplate().get(entityClass, id);
}
@Override
public Collection<T> loadAll() {
return getHibernateTemplate().loadAll(entityClass);
}
@Override
public void delete(T entity) {
getHibernateTemplate().delete(entity);
}
}
اینجا میشد مثلا از JPA یا JdcbTemplate و ... استفاده کرد.
نوبت به پیاده سازی IProductRepository میرسه که متدهای اضافه ای هم بهش اضافه کرده بودیم.
قبلش این named query ها رو به بالای کلاس Product اضافه میکنیم تا برای پیاده سازی IProductRepository ازشون استفاده کنیم :
package test.model.entity;
import javax.persistence.*;
import java.util.Date;
@Table
@Entity
@NamedQueries({
@NamedQuery(name = "product_countByName", query = "select count(*) from Product p where p.name = (:name)"),
@NamedQuery(name = "product_findByName", query = "select p from Product p where p.name = (:name)")
})
public class Product extends BaseEntity {
//...
ProductRepository :
package test.model.repository;
import org.hibernate.SessionFactory;
import org.springframework.beans.factory.annotation.Autow ired;
import org.springframework.stereotype.Repository;
import test.model.entity.Product;
@Repository(value = "productRepository")
public class ProductRepository extends HibernateRepository<Product> implements IProductRepository {
@Autowired
public ProductRepository(SessionFactory sessionFactory) {
super(sessionFactory);
setEntityClass(Product.class);
}
@Override
public boolean productExistsByName(String name) {
Object o = getHibernateTemplate().getSessionFactory().getCurr entSession()
.getNamedQuery("product_countByName")
.setParameter("name", name)
.uniqueResult();
return o != null && (int) o > 0;
}
@Override
public Product findByName(String name) {
Object o = getHibernateTemplate().getSessionFactory().getCurr entSession()
.getNamedQuery("product_findByName")
.setParameter("name", name)
.uniqueResult();
return o == null ? null : (Product) o;
}
}
انوتیشین Autowired بالای کانستراکتور برای اینه که به اسپرینگ بگیم موقع new کردن این آبجکت یک SessionFactory بهش inject کنه.
هنوز کار تموم نشده و باید نحوه استفاده از transaction روی دیتابیس رو بررسی کنیم. معمولا روشی که ازش استفاده میکنن اینه که یک لایه دیگه ای بالا repository تعریف میکنن (Service) و از طریق اون transaction رو مدیریت میکنن. در واقع این لایه میشه واسط بین لایه مدل و کنترلر.
IProductService :
package test.model.service;
import test.model.entity.Product;
import java.util.Date;
public interface IProductService {
boolean addProduct(String name, Date productionDate, float price);
Product findByName(String name);
boolean deleteProduct(String name);
//...
}
و پیاده سازیش :
package test.model.service;
import org.springframework.beans.factory.annotation.Autow ired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transac tional;
import test.model.entity.Product;
import test.model.repository.IProductRepository;
import java.util.Date;
@Service(value = "productService")
@Transactional
public class ProductService implements IProductService {
@Autowired
private IProductRepository productRepository;
@Override
public boolean addProduct(String name, Date productionDate, float price) {
if (productRepository.productExistsByName(name)) {
return false;
}
Product product = new Product(name, productionDate, price);
productRepository.save(product);
return true;
}
@Override
public Product findByName(String name) {
return productRepository.findByName(name);
}
@Override
public boolean deleteProduct(String name) {
Product product = productRepository.findByName(name);
if (product == null) {
return false;
}
productRepository.delete(product);
return true;
}
}
انوتیشن Transactional باعث میشه که اسپرینگ هر وقت متدی از این کلاس صدا زده شد یک Transaction باز کنه و در آخر اونو ببنده (البته به این سادگیا هم نیست، یه سری بهینه سازی های دیگه هم انجام میده) . تنظیمات دیگه ای هم میشه براش انجام داد... (مثلا این که متد findByName نیازی به transaction نداره و readOnly هم باشه براش مشکلی پیش نمیاد).
تا اینجا کار لایه مدل تموم شد و باید بریم سراغ کنترلر. دیگه کار برای این لایه آسون تر میشه.
IProductController :
package test.controller;
import test.model.entity.Product;
public interface IProductController {
String addProduct(String name, float price);
Product findProduct(String name);
}
و ProductController :
package test.controller;
import org.springframework.beans.factory.annotation.Autow ired;
import org.springframework.web.bind.annotation.RequestMap ping;
import org.springframework.web.bind.annotation.RequestPar am;
import org.springframework.web.bind.annotation.RestContro ller;
import test.model.entity.Product;
import test.model.service.IProductService;
import java.util.Date;
@RestController(value = "productController")
@RequestMapping(value = "/products")
public class ProductController implements IProductController {
@Autowired
private IProductService productService;
@Override
@RequestMapping(value = "/add")
public String addProduct(@RequestParam(value = "name") String name, @RequestParam(value = "price") float price) {
return productService.addProduct(name, new Date(), price)
? "Successfully added new product."
: "Product name already exists!";
}
@Override
@RequestMapping(value = "/find")
public Product findProduct(@RequestParam(value = "name") String name) {
return productService.findByName(name);
}
}
اگر دقت کنی توی هر لایه از annotation های خاصی استفاده کردیم. مثلا توی لایه مدل از Repository و Service و توی لایه کنترلر از Controller.
با این کار این bean هارو به اسپرینگ میشناسونیم و از طریق Autowired به هم تزریقشون میکنیم.