Spring baseDao封装，Spring jdbcTemplate封装，springJdbc泛型Dao，SpringJdbc持久层封装
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
©Copyright 蕃薯耀 2017年7月6日
http://fanshuyao.iteye.com/
很久之前弄的Spring Jdbc持久化层的baseDao，现在做个记录。
基本的增、删、查、改、分页、排序都可以用，只是兼容一般，如主键必须是id，并没有深入再封装。
封装基于Spring4+Mysql
package com.lqy.spring.dao.impl;
import java.io.Serializable;
import java.lang.reflect.Field;
import java.lang.reflect.Method;
import java.util.ArrayList;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;
import org.springframework.beans.BeanWrapper;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.jdbc.core.BeanPropertyRowMapper;
import org.springframework.jdbc.core.JdbcTemplate;
import com.lqy.Utils.EntityUtils;
import com.lqy.Utils.StrUtils;
import com.lqy.spring.bean.Page;
import com.lqy.spring.dao.BaseDao;
import com.lqy.spring.editor.GenderEditor;
import com.lqy.spring.entity.SqlEntity;
import com.lqy.spring.enums.Gender;
@SuppressWarnings({"unchecked","rawtypes"})
public class BaseDaoImpl<T> implements BaseDao<T> {
@Autowired
JdbcTemplate jdbcTemplate;
//entityClass.getSimpleName()=Person
//entityClass.getName()=com.lqy.spring.c3p0.beans.Person
protected Class<T> entityClass = (Class<T>) EntityUtils.getEntityClass(this.getClass());
//private RowMapper<T> rowMapper = new BeanPropertyRowMapper<T>(entityClass);
private BeanPropertyRowMapper<T> rowMapper = new BeanPropertyRowMapper<T>(entityClass){
@Override
protected void initBeanWrapper(BeanWrapper bw) {
bw.registerCustomEditor(Gender.class, new GenderEditor());
super.initBeanWrapper(bw);
}
};
/**
* 获取实体
* @param id 对象的id(Serializable)
* @return T 对象
* @author lqy
* @since 2015-10-18
*/
@Override
public T get(Serializable id) {
String sql = getSql() + "and id=? ";
return (T)jdbcTemplate.queryForObject(sql, rowMapper, id);
}
/**
* 查询
* @return List<T>
* @author lqy
* @since 2015-10-18
*/
@Override
public List<T> query() {
return (List<T>) jdbcTemplate.query(getSql(), rowMapper);
}
/**
* 查询
* @param page 分页参数
* @param whereSql 查询条件（例:o.name=?）
* @param params 查询条件对应的参数(List<Object>)
* @return List<T>
* @author lqy
* @since 2015-10-18
*/
@Override
public List<T> query(Page page, String whereSql, List<Object> params) {
List<Object> paramList = new ArrayList<Object>();
if(!StrUtils.isEmpty(whereSql) && !StrUtils.isEmpty(params)){
for (Object object : params) {
if(object instanceof Enum){
paramList.add(((Enum)object).ordinal());
}else{
paramList.add(object);
}
}
}
String sql = getSql(page, whereSql, null);
dealPage(page, sql, paramList);
if(!StrUtils.isEmpty(page)){
paramList.add(page.getOffSize());
paramList.add(page.getCurrentSize());
}
return (List<T>)jdbcTemplate.query(sql, rowMapper, paramList.toArray());
}
/**
* 查询
* @param page 分页参数
* @param orderby 排序条件（LinkedHashMap<String, String>）
* @return List<T>
* @author lqy
* @since 2015-10-18
*/
@Override
public List<T> query(Page page, LinkedHashMap<String, String> orderby) {
List<Object> paramsList = new ArrayList<Object>();
String sql = getSql(page, null, orderby);
dealPage(page, sql, paramsList);
if(!StrUtils.isEmpty(page)){
paramsList.add(page.getOffSize());
paramsList.add(page.getCurrentSize());
}
return (List<T>)jdbcTemplate.query(sql, rowMapper, paramsList.toArray());
}
/**
* 查询
* @param page 分页参数
* @param whereSql 查询条件（例:o.name=?）
* @param params 查询条件对应的参数(List<Object>)
* @param orderby 排序条件（LinkedHashMap<String, String>）
* @return List<T>
* @author lqy
* @since 2015-10-18
*/
@Override
public List<T> query(Page page, String whereSql, List<Object> params, LinkedHashMap<String, String> orderby) {
List<Object> paramsList = new ArrayList<Object>();
if(!StrUtils.isEmpty(whereSql) && !StrUtils.isEmpty(params)){
for (Object object : params) {
if(object instanceof Enum){
paramsList.add(((Enum)object).ordinal());
}else{
paramsList.add(object);
}
}
}
String sql = getSql(page, whereSql, orderby);
//System.out.println("sql ="+sql);
dealPage(page, sql, paramsList);
if(!StrUtils.isEmpty(page)){
paramsList.add(page.getOffSize());
paramsList.add(page.getCurrentSize());
}
return (List<T>)jdbcTemplate.query(sql, rowMapper, paramsList.toArray());
}
/**
* 更新
* @param sql 自定义更新sql
* @param params 查询条件对应的参数(List<Object>)
* @return int 更新的数量
* @author lqy
* @since 2015-10-18
*/
@Override
public int update(String sql, List<Object> params) {
//String sql="update person set name=? where id=?";
return jdbcTemplate.update(sql, params.toArray());
}
/**
* 更新（先从数据库取出来再更新）
* @param t 更新的对象
* @return int 更新的数量
* @author lqy
* @since 2015-10-18
*/
@Override
public int update(T t) throws Exception{
SqlEntity sqlEntity = getUpdateSql(t);
//System.out.println("=====sqlEntity.getSql()="+sqlEntity.getSql());
return jdbcTemplate.update(sqlEntity.getSql(), sqlEntity.getParams().toArray());
}
/**
* 更新（通过模板更新，把符合template条件的数据都更新为value对象中的值）
* @param t 更新的对象
* @return int 更新的数量
* @author lqy
* @since 2015-10-18
*/
@Override
public int update(T value,T template) throws Exception{
SqlEntity sqlEntity = getUpdateSql(value,template);
//System.out.println("=====update(T value,T template) sqlEntity.getSql()="+sqlEntity.getSql());
return jdbcTemplate.update(sqlEntity.getSql(), sqlEntity.getParams().toArray());
}
/**
* 保存
* @param t 保存的对象
* @return int 保存的数量
* @author lqy
* @since 2015-10-18
*/
@Override
public int save(T t) throws Exception{
SqlEntity sqlEntity = getSaveSql(t);
return jdbcTemplate.update(sqlEntity.getSql(), sqlEntity.getParams().toArray());
};
/**
* 保存
* @param sql 自定义保存sql
* @param params 查询条件对应的参数(List<Object>)
* @return int 保存的数量
* @author lqy
* @since 2015-10-18
*/
@Override
public int save(String sql, List<Object> params) {
//String sql="INSERT INTO person (`name`,age,create_time) VALUES(?,?,?);";
return jdbcTemplate.update(sql, params.toArray());
}
/**
* 删除
* @param id 对象的id(Serializable)
* @return int 删除的数量
* @author lqy
* @since 2015-10-18
*/
@Override
public int delete(Serializable id) {
String sql="delete from " + StrUtils.changeName(this.entityClass.getSimpleName()) + " where id=?";
return jdbcTemplate.update(sql, id);
}
@SuppressWarnings("deprecation")
@Override
public int getCount(String whereSql, Object[] objects){
String entityName = this.entityClass.getSimpleName();
StringBuffer sql = new StringBuffer("select count(*) from ");
sql.append(StrUtils.changeName(entityName));
sql.append(" o ").append(whereSql);
//System.out.println("getCount sql.toString()="+sql.toString());
//return jdbcTemplate.queryForInt(sql.toString(), entityClass);
return jdbcTemplate.queryForInt(sql.toString(), objects);
}
protected String getSql(){
String entityName = this.entityClass.getSimpleName();
StringBuffer sql = new StringBuffer("select * from ");
sql.append(StrUtils.changeName(entityName));
sql.append(" o where 1=1 ");
return sql.toString();
}
protected String getSql(String whereSql){
String entityName = this.entityClass.getSimpleName();
StringBuffer sql = new StringBuffer("select * from ");
sql.append(StrUtils.changeName(entityName));
sql.append(" o where 1=1 ");
if(!StrUtils.isEmpty(whereSql)){
sql.append(" ").append(whereSql);
}
return sql.toString();
}
/**
* 获取sql
* @param page 分页参数，如果为空，则不在sql增加limit ?,?
* @param orderby 排序参数，如果为空，则不在sql增加ORDER BY
* @param whereSql 查询条件参数，如果为空，则不在sql增加 and name=?
* @return sql
*/
protected String getSql(Page page, String whereSql, Map<String,String> orderby){
String entityName = this.entityClass.getSimpleName();
StringBuffer sql = new StringBuffer("select * from ");
sql.append(StrUtils.changeName(entityName));
sql.append(" o where 1=1 ");
if(!StrUtils.isEmpty(whereSql)){
sql.append(" ").append(whereSql);
}
if(!StrUtils.isEmpty(orderby)){
sql.append(" ORDER BY ");
for (String string : orderby.keySet()) {
String value = orderby.get(string);
if(StrUtils.isEmpty(value)){
value = "ASC";
}
sql.append("o.").append(string).append(" ").append(value.toUpperCase()).append(",");
}
if(sql.indexOf(",") > -1){
sql.deleteCharAt(sql.length()-1);
}
}
if(!StrUtils.isEmpty(page)){
sql.append(" limit ?,? ");
}
//System.out.println("------sql.toString()="+sql.toString());
return sql.toString();
}
private SqlEntity getUpdateSql(T t) throws Exception{
SqlEntity sqlEntity = new SqlEntity();
sqlEntity.setParams(new ArrayList<Object>());
Field[] fields = entityClass.getDeclaredFields();
StringBuffer sql = new StringBuffer("");
sql.append("update ").append(StrUtils.changeName(entityClass.getSimpleName())).append(" o set ");
for (Field field : fields) {
StringBuffer methodName = new StringBuffer("");
//System.out.println("===field.getType()="+field.getType());
if(field.getType() == boolean.class){
if(field.getName().contains("is")){
methodName.append(field.getName());
}else{
methodName.append("is").append(StrUtils.firstCodeToUpperCase(field.getName()));
}
}else{
methodName.append("get").append(StrUtils.firstCodeToUpperCase(field.getName()));
}
if(!"id".equals(field.getName())){
Method method = entityClass.getMethod(methodName.toString(), new Class[]{});
Object objectValue = method.invoke(t, new Object[]{});
if(objectValue instanceof Enum){
sqlEntity.getParams().add(((Enum)objectValue).ordinal());
}else{
sqlEntity.getParams().add(objectValue);
}
sql.append(" o.").append(StrUtils.changeName(field.getName())).append("= ?,");
}
}
if(sql.indexOf(",") > -1){
sql.deleteCharAt(sql.length() - 1);
}
sql.append(" where o.id=?");
Method idMethod = entityClass.getMethod("getId", new Class[]{});
sqlEntity.getParams().add(idMethod.invoke(t, new Object[]{}));
sqlEntity.setSql(sql.toString());
return sqlEntity;
}
private SqlEntity getUpdateSql(T value, T template) throws Exception{
SqlEntity sqlEntity = new SqlEntity();
sqlEntity.setParams(new ArrayList<Object>());
Field[] fields = entityClass.getDeclaredFields();
StringBuffer sql = new StringBuffer("");
sql.append("update ").append(StrUtils.changeName(entityClass.getSimpleName())).append(" o set ");
StringBuffer whereSql = new StringBuffer(" where ");
for (Field field : fields) {
StringBuffer methodName = new StringBuffer("");
//System.out.println("===field.getType()="+field.getType());
if(field.getType() == boolean.class){
if(field.getName().contains("is")){
methodName.append(field.getName());
}else{
methodName.append("is").append(StrUtils.firstCodeToUpperCase(field.getName()));
}
}else{
methodName.append("get").append(StrUtils.firstCodeToUpperCase(field.getName()));
}
if(!"id".equals(field.getName())){
Method method = entityClass.getMethod(methodName.toString(), new Class[]{});
Object objectValue = method.invoke(value, new Object[]{});
if(!StrUtils.isEmpty(objectValue)){
if(objectValue instanceof Enum){
sqlEntity.getParams().add(((Enum)objectValue).ordinal());
}else{
sqlEntity.getParams().add(objectValue);
}
//sqlEntity.getParams().add(objectValue);
sql.append(" o.").append(StrUtils.changeName(field.getName())).append("= ?,");
}
}
}
for (Field field : fields) {
StringBuffer methodName = new StringBuffer("");
if(field.getType() == boolean.class){
if(field.getName().contains("is")){
methodName.append(field.getName());
}else{
methodName.append("is").append(StrUtils.firstCodeToUpperCase(field.getName()));
}
}else{
methodName.append("get").append(StrUtils.firstCodeToUpperCase(field.getName()));
}
Method method = entityClass.getMethod(methodName.toString(), new Class[]{});
Object objectValue = method.invoke(template, new Object[]{});
if(!StrUtils.isEmpty(objectValue)){
sqlEntity.getParams().add(objectValue);
whereSql.append(" o.").append(StrUtils.changeName(field.getName())).append("= ? and");
}
}
if(sql.indexOf(",") > -1){
sql.deleteCharAt(sql.length() - 1);
}
if(whereSql.indexOf("and") > -1){
sql.append(whereSql.substring(0, whereSql.length()-3));
whereSql = new StringBuffer();
}else{
sql.append(whereSql);
}
sqlEntity.setSql(sql.toString());
return sqlEntity;
}
private SqlEntity getSaveSql(T t) throws Exception{
SqlEntity sqlEntity = new SqlEntity();
sqlEntity.setParams(new ArrayList<Object>());
Field[] fields = entityClass.getDeclaredFields();
StringBuffer sql = new StringBuffer("");
sql.append("insert into ").append(StrUtils.changeName(entityClass.getSimpleName())).append(" ( ");
int paramLength = 0;
for (Field field : fields) {
StringBuffer methodName = new StringBuffer("");
if(field.getType() == boolean.class){
if(field.getName().contains("is")){
methodName.append(field.getName());
}else{
methodName.append("is").append(StrUtils.firstCodeToUpperCase(field.getName()));
}
}else{
methodName.append("get").append(StrUtils.firstCodeToUpperCase(field.getName()));
}
Method method = entityClass.getMethod(methodName.toString(), new Class[]{});
Object value = method.invoke(t, new Object[]{});
if(!StrUtils.isEmpty(value)){
if(value instanceof Enum){
sqlEntity.getParams().add(((Enum) value).ordinal());
}else{
sqlEntity.getParams().add(value);
}
sql.append("`").append(StrUtils.changeName(field.getName())).append("`").append(",");
paramLength ++;
}
}
if(sql.indexOf(",") > -1){
sql.deleteCharAt(sql.length() - 1);
}
sql.append(") values(");
for (int i=0;i<paramLength;i++) {
sql.append("?,");
}
if(sql.indexOf(",") > -1){
sql.deleteCharAt(sql.length() - 1);
}
sql.append(")");
//System.out.println("sql.toString()="+sql.toString());
sqlEntity.setSql(sql.toString());
return sqlEntity;
}
private void dealPage(Page page, String sql, List<Object> params){
String whereSql = "";
if(sql != null && !sql.trim().equals("")){
int whereIndex = sql.toLowerCase().indexOf("where");
int orderIndex = sql.toLowerCase().indexOf("order");
int limitIndex = sql.toLowerCase().indexOf("limit");
if(whereIndex > -1){
whereSql = sql.substring(whereIndex, sql.length());
orderIndex = whereSql.toLowerCase().indexOf("order");
}
if(whereIndex > -1 && orderIndex > -1){
whereSql = whereSql.substring(0, orderIndex - 1);
limitIndex = whereSql.toLowerCase().indexOf("limit");
}
if(whereIndex > -1 && limitIndex > -1){
whereSql = whereSql.substring(0, limitIndex - 1);
}
}
if(page.getTotalSizeNew()){
page.setTotalSize(getCount(whereSql, params.toArray()));
}
setPage(page);
}
private void setPage(Page page){
page.setTotalPages(page.getTotalSize()%page.getCurrentSize()==0?page.getTotalSize()/page.getCurrentSize():(page.getTotalSize()/page.getCurrentSize()+1));
page.setCurrentPage(page.getOffSize()/page.getCurrentSize()+1);
}
}
package com.lqy.spring.dao;
import java.io.Serializable;
import java.util.LinkedHashMap;
import java.util.List;
import com.lqy.spring.bean.Page;
public interface BaseDao<T> {
public T get(Serializable id);
public List<T> query();
public List<T> query(Page page, String whereSql, List<Object> params);
public List<T> query(Page page, LinkedHashMap<String, String> orderby);
public List<T> query(Page page, String whereSql, List<Object> params, LinkedHashMap<String, String> orderby);
public int update(String sql, List<Object> params);
public int update(T t) throws Exception;
public int update(T value,T template) throws Exception;
public int save(T t) throws Exception;
public int save(String sql, List<Object> params);
public int delete(Serializable id);
public int getCount(String whereSql, Object[] objects);
}
package com.lqy.spring.service.impl;
import java.io.Serializable;
import java.util.LinkedHashMap;
import java.util.List;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.transaction.annotation.Isolation;
import org.springframework.transaction.annotation.Transactional;
import com.lqy.spring.bean.Page;
import com.lqy.spring.dao.BaseDao;
import com.lqy.spring.service.BaseService;
@Transactional
public class BaseServiceImpl<T> implements BaseService<T> {
@Autowired
BaseDao<T> baseDao;
/**
* 获取实体
* @param id 对象的id(Serializable)
* @return T 对象
* @author lqy
* @since 2015-10-18
*/
@Transactional(isolation=Isolation.READ_COMMITTED,
readOnly=true)
@Override
public T get(Serializable id) {
return baseDao.get(id);
}
/**
* 查询
* @return List<T>
* @author lqy
* @since 2015-10-18
*/
@Transactional(isolation=Isolation.READ_COMMITTED,readOnly=true)
@Override
public List<T> query() {
return baseDao.query();
}
/**
* 查询
* @param page 分页参数
* @param whereSql 查询条件（例:o.name=?）
* @param params 查询条件对应的参数(List<Object>)
* @return List<T>
* @author lqy
* @since 2015-10-18
*/
@Transactional(isolation=Isolation.READ_COMMITTED,
readOnly=true)
@Override
public List<T> query(Page page, String whereSql, List<Object> params) {
return baseDao.query(page, whereSql, params);
}
/**
* 查询
* @param page 分页参数
* @param orderby 排序条件（LinkedHashMap<String, String>）
* @return List<T>
* @author lqy
* @since 2015-10-18
*/
@Transactional(isolation=Isolation.READ_COMMITTED,
readOnly=true)
@Override
public List<T> query(Page page, LinkedHashMap<String, String> orderby) {
return baseDao.query(page, orderby);
}
/**
* 查询
* @param page 分页参数
* @param whereSql 查询条件（例:o.name=?）
* @param params 查询条件对应的参数(List<Object>)
* @param orderby 排序条件（LinkedHashMap<String, String>）
* @return List<T>
* @author lqy
* @since 2015-10-18
*/
@Transactional(isolation=Isolation.READ_COMMITTED,
readOnly=true)
@Override
public List<T> query(Page page, String whereSql, List<Object> params,
LinkedHashMap<String, String> orderby) {
return baseDao.query(page, whereSql, params, orderby);
}
/**
* 更新
* @param sql 自定义更新sql
* @param params 查询条件对应的参数(List<Object>)
* @return int 更新的数量
* @author lqy
* @since 2015-10-18
*/
@Override
public int update(String sql, List<Object> params) {
return baseDao.update(sql, params);
}
/**
* 更新（先从数据库取出来再更新）
* @param t 更新的对象
* @return int 更新的数量
* @author lqy
* @since 2015-10-18
*/
@Override
public int update(T t) throws Exception {
return baseDao.update(t);
}
/**
* 更新（通过模板更新，把符合template条件的数据都更新为value对象中的值）
* @param t 更新的对象
* @return int 更新的数量
* @author lqy
* @since 2015-10-18
*/
@Override
public int update(T value,T template) throws Exception{
return baseDao.update(value,template);
}
/**
* 保存
* @param t 保存的对象
* @return int 保存的数量
* @author lqy
* @since 2015-10-18
*/
@Override
public int save(T t) throws Exception {
return baseDao.save(t);
}
/**
* 保存
* @param sql 自定义保存sql
* @param params 查询条件对应的参数(List<Object>)
* @return int 保存的数量
* @author lqy
* @since 2015-10-18
*/
@Override
public int save(String sql, List<Object> params) {
return baseDao.save(sql, params);
}
/**
* 删除
* @param id 对象的id(Serializable)
* @return int 删除的数量
* @author lqy
* @since 2015-10-18
*/
@Override
public int delete(Serializable id) {
return baseDao.delete(id);
}
}
package com.lqy.spring.service;
import java.io.Serializable;
import java.util.LinkedHashMap;
import java.util.List;
import com.lqy.spring.bean.Page;
public interface BaseService<T> {
public T get(Serializable id);
public List<T> query();
public List<T> query(Page page, String whereSql, List<Object> params);
public List<T> query(Page page, LinkedHashMap<String, String> orderby);
public List<T> query(Page page, String whereSql, List<Object> params, LinkedHashMap<String, String> orderby);
public int update(String sql, List<Object> params);
public int update(T t) throws Exception;
public int update(T value,T template) throws Exception;
public int save(T t) throws Exception;
public int save(String sql, List<Object> params);
public int delete(Serializable id);
}
package com.lqy.spring.bean;
public class Page {
private int currentSize;
private int offSize;
private int totalSize;
private int totalPages;
private int currentPage;
private Boolean totalSizeNew;
/**
* 分页构造函数
* @author lqy
* @since 2015-10-22
*/
public Page() {
super();
}
/**
* 分页构造函数
* @param currentSize
* @param offSize
* @author lqy
* @since 2015-10-22
*/
public Page(int currentSize, int offSize) {
super();
this.currentSize = currentSize;
this.offSize = offSize;
}
/**
* 分页构造函数
* @param currentSize
* @param offSize
* @param totalSizeNew
* @author lqy
* @since 2015-10-22
*/
public Page(int currentSize, int offSize, boolean totalSizeNew) {
super();
this.currentSize = currentSize;
this.offSize = offSize;
this.totalSizeNew = totalSizeNew;
}
/**
* 分页构造函数
* @param currentSize
* @param offSize
* @param totalSize
* @param totalPages
* @param currentPage
* @param totalSizeNew
* @author lqy
* @since 2015-10-22
*/
public Page(int currentSize, int offSize, int totalSize, int totalPages,
int currentPage, boolean totalSizeNew) {
super();
this.currentSize = currentSize;
this.offSize = offSize;
this.totalSize = totalSize;
this.totalPages = totalPages;
this.currentPage = currentPage;
this.totalSizeNew = totalSizeNew;
}
public int getCurrentSize() {
return currentSize;
}
public void setCurrentSize(int currentSize) {
this.currentSize = currentSize;
}
public int getOffSize() {
return offSize;
}
public void setOffSize(int offSize) {
this.offSize = offSize;
}
public int getTotalSize() {
return totalSize;
}
public void setTotalSize(int totalSize) {
this.totalSize = totalSize;
}
public int getTotalPages() {
return totalPages;
}
public void setTotalPages(int totalPages) {
this.totalPages = totalPages;
}
public int getCurrentPage() {
return currentPage;
}
public void setCurrentPage(int currentPage) {
this.currentPage = currentPage;
}
public Boolean getTotalSizeNew() {
return totalSizeNew;
}
public void setTotalSizeNew(Boolean totalSizeNew) {
this.totalSizeNew = totalSizeNew;
}
@Override
public String toString() {
return "Page [currentSize=" + currentSize + ", offSize=" + offSize
+ ", totalSize=" + totalSize + ", totalPages=" + totalPages
+ ", currentPage=" + currentPage + ", totalSizeNew="
+ totalSizeNew + "]";
}
}
使用的一个例子：
package com.lqy.spring.service.impl;
import java.util.ArrayList;
import java.util.LinkedHashMap;
import java.util.List;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import com.lqy.Utils.StrUtils;
import com.lqy.exception.PersonMoneyNotEnoughException;
import com.lqy.spring.bean.Page;
import com.lqy.spring.bean.Person;
import com.lqy.spring.dao.PersonDao;
import com.lqy.spring.service.BookService;
import com.lqy.spring.service.PersonService;
@Service
public class PersonServiceImpl extends BaseServiceImpl<Person> implements PersonService {
@Autowired
PersonDao personDao;
@Autowired
BookService bookService;
@Override
public List<Person> getPersons(Page page, String name, Integer age, Integer statusType){
StringBuffer whereSql = new StringBuffer();
List<Object> params = new ArrayList<Object>();
LinkedHashMap<String, String> orderby = new LinkedHashMap<String, String>();
if(!StrUtils.isEmpty(name)){
whereSql.append(" and o.name like ?");
params.add("%"+name+"%");
}
if(!StrUtils.isEmpty(age)){
whereSql.append(" and o.age = ?");
params.add(age);
}
if(!StrUtils.isEmpty(statusType)){
whereSql.append(" and o.statusType = ?");
params.add(statusType);
}
orderby.put("create_time", "desc");
orderby.put("id", "desc");
return personDao.query(page, whereSql.toString(), params, orderby);
}
@Transactional
public int buyBook(Integer personId, Double price) throws Exception{
int result = -1;
Person person = personDao.get(personId);
if(!StrUtils.isEmpty(person)){
Double leftMoney = person.getMoney() - price;
if(leftMoney >= 0){
person.setMoney(leftMoney);
result = personDao.update(person);
}else{
throw new PersonMoneyNotEnoughException();
}
}
return result;
}
@Transactional
@Override
public int buyBook(Integer personId, Integer bookId, Integer amount) throws Exception{
int result = -1;
Person person = personDao.get(personId);
if(!StrUtils.isEmpty(person)){
Double price = bookService.getBooksPrices(bookId, amount);
Double leftMoney = person.getMoney() - price;
if(leftMoney >= 0){
person.setMoney(leftMoney);
personDao.update(person);
bookService.sellBooks(bookId, amount);
result = 1;
}else{
throw new PersonMoneyNotEnoughException();
}
}
return result;
}
}
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
©Copyright 蕃薯耀 2017年7月6日
http://fanshuyao.iteye.com/
相关推荐
使用baseDao封装基本的增删改查的方法，包括分页查询等功能
Mybatis是一款轻量级的持久层框架，它避免了几乎所有的JDBC代码和手动设置参数以及获取结果集。通过提供自定义SQL、存储过程以及高级映射，Mybatis使得开发者能够专注于编写高质量的代码，而无需关心底层数据库交互...
### 基于Spring JDBC的BaseDAO实现与应用 #### 概述 在Java开发领域，尤其是企业级应用开发中，持久层框架是至关重要的组件之一。Spring框架提供了多种方式来处理数据库操作，其中Spring JDBC模块是轻量级且功能...
基于Spring JDBC 的一个公用持久化层源代码，支持普通的增删改查，仅支持Spring JDBC环境使用~
在提供的文件列表中，`BaseDao.java`和`BaseDaoImpl.java`很可能是自定义的基类和实现类，用于封装JdbcTemplate的常用操作。BaseDao通常会定义一些基本的CRUD（创建、读取、更新、删除）方法，如`selectById(int id)...
通过这个项目，你可以学习到如何利用Spring的JDBCTemplate和Java POJO来构建一个可复用、易于维护的DAO层，提升代码的可读性和可扩展性。同时，这也是一个良好的实践，帮助开发者遵循面向接口编程和低耦合的设计原则...
本项目结合了Spring 4和Hibernate 4，旨在提供一个基础的数据访问层（DAO）实现，包括基本的CRUD操作（创建、读取、更新、删除）以及分页功能。以下是关于这个项目的详细知识点： 1. **Spring 4**：Spring框架是...
本文将深入探讨如何使用ORMLite在Android中构建一个万能泛型Dao，以实现数据持久化的高效管理。 首先，我们需要理解什么是ORM。ORM是Object-Relational Mapping的缩写，它的主要作用是提供一种机制，将数据库的表格...
例如，可以有一个`BaseDao<T>`接口，其中T代表任意实体类型，然后针对每种实体创建具体的Dao实现类。 在实际开发中，`base`可能是指基础配置文件或者示例代码，包括Spring的bean配置文件（如`beans.xml`）、Struts2...
本篇文章将介绍一个基于JDBC封装的`BaseDao`实例，该实例提供了一个通用的DAO（Data Access Object）模板，可以应用于多种实体类的操作。 首先，`BaseDao`泛型类被定义为`<T>`，表示它可以处理任何类型的对象。类中...
在数据层封装中，泛型通常被用来创建通用的DAO（Data Access Object）类，这样我们就可以为不同的数据库表或对象创建单一的DAO实现，只需要指定对应的实体类类型即可。例如，我们可以定义一个`BaseDAO<T>`，其中`T`...
4. **泛型DAO**: 在SSH框架中，泛型DAO是一种常见的设计模式，用于封装对数据库的基本操作，如增删查改。通过泛型，我们可以创建一个通用的DAO接口和实现，减少代码重复，提高代码复用。例如，我们可以创建一个`...
"Hibernate封装DAO层"就是将Hibernate的功能整合到DAO设计模式中，以实现更加高效、规范的数据库操作。 1. **DAO设计模式**： DAO模式是软件设计模式的一种，它的核心思想是创建一个独立于具体数据库操作的对象，...
在Java开发中，BaseDao和BaseService是常见的设计模式，用于实现数据访问层（DAO）和业务逻辑层（Service）的抽象基类。通过结合泛型，我们可以创建更通用、灵活的代码，减少冗余并提高代码质量。 首先，我们来理解...
在`BaseDao.java`中，可能会定义一个泛型基类，如： ```java public abstract class BaseDao<T> { public abstract void save(T entity); public abstract T findById(ID id); // 其他通用操作 } ``` 这里的`...
在SSH框架中，我们可以创建一个基础的泛型DAO接口，如`BaseDao<T>`，其中`T`代表任何实体类。这个接口通常包含基本的CRUD（创建、读取、更新、删除）操作，如`save()`, `get()`, `update()`, 和 `delete()`。然后，...
2、基于spring jdbc的上层封装，底层jdbc操作基于JdbcTemplate，对于使用spring jdbc的人会有一点价值，比较简洁的封装可以节省很多重复劳动，具体节省多少可以看看example； 3、实现一套简单的ORM（直接使用...
在IT行业中，数据库操作是应用程序的核心部分，而`BaseDao`的封装则是一种常见的设计模式，用于简化数据库访问层（DAO）的实现。这个模式的主要目的是提高代码的可复用性和可维护性，减少重复的SQL操作代码。下面...
在Java的持久层框架Hibernate中，BaseDAO（基础数据访问对象）是常用的设计模式，用于封装对数据库的基本操作。在给定的“hibernate basedao（泛型版本）”中，开发人员通过引入泛型进一步提高了代码的复用性和灵活...
在Java Web开发中，S2SH（Struts2 + Spring + Hibernate）是一个常见的技术栈，它结合了MVC框架Struts2、依赖注入容器Spring以及持久层框架Hibernate，以实现高效且灵活的Web应用开发。在这个基于Annotation并对DAO...