Java 仓储模式

使用的Spring boot +Jpa

项目层级：

common里包含了model，以及一些viewModel等等

下面就是设计的仓储模式

先看下SysUser:

@MappedSuperclass
public class SuperBaseModel {
//基本属性
}

@MappedSuperclass
public class BaseModel extends SuperBaseModel {
//枚举值：https://blog.csdn.net/hanjun0612/article/details/72845960
    private Integer isValid =EnumList.ValidEnum.Valid.getEnumItem().getItemKey();

    @Column(name="IsValid")
    public Integer getIsValid() {
        return isValid;
    }

    public void setIsValid(Integer isValid) {
        this.isValid = isValid;
    }
    
  
}

@Entity
@Table(name = "sys_user", catalog = "kps_business")
@DynamicUpdate
public class SysUser extends BaseModel implements java.io.Serializable {
  //get set  
}

枚举值，请查看  https://blog.csdn.net/hanjun0612/article/details/72845960

一，dao创建MyJpa

@NoRepositoryBean
public interface MyJpaRepository<T,ID extends Serializable> extends JpaRepository <T,ID>,JpaSpecificationExecutor<T>{
 
}

接着创建一个 SysUserDao，里面额外创建了3个方法。

@Repository
public interface SysUserDao extends MyJpaRepository<SysUser, String>{
    public SysUser getByAccount(String account);
    public SysUser getByAccountAndPlatformUUID(String account,String platformUUID);
    public SysUser getByUserUUId(String userUUId);
}

这里MyJpaRepository<SysUser,String>

首先传入的是对象SysUser,其次传入了一个String 的UUID

如果你是Integer，那你自行修改就可以了。

二，service

先创建BaseSuperService

public interface BaseSuperService<T extends SuperBaseModel,ID extends Serializable> extends MyJpaRepository<T, ID> {
    /**
     * 分页查询
     */
    PageResult<T> pagedList(T entity,Integer currentPage,Integer pageSize,Order...orders);
    
    PageResult<T> pagedList(T entity,Integer currentPage,Order...orders);
}

接着创建BaseService

public interface BaseService<T extends BaseModel,ID extends Serializable> extends BaseSuperService<T, ID> {
 
    /**
     * 分页查询(有效的记录)
     */
    PageResult<T> pagedListForVaild(T entity,Integer currentPage,Integer pageSize,Order...orders) throws Exception;
    
    PageResult<T> pagedListForVaild(T entity,Integer currentPage,Order...orders) throws Exception;
 
}

这里，你可以只创建一个BaseService。我是由于后期有两个领域模型

第一个领域模型，只需要BaseSuperService的pagedList方法

第二个领域模型，需要BaseSuperService的pagedList方法，以及BaseService的PagedListForVaild方法

因此才创建了两个层级。

最后创建UserService

public interface SysUserService extends BaseService<SysUser,String>{
    public SysUser getByAccountAndPlatformUUID(String account,String platformUUID);
    public SysUser getByAccount(String account);
    public SysUser getByUserUUId(String userUUID);
}

三，创建Impl

首先创建BaseSuperServiceImpl

@SuppressWarnings({"unchecked", "rawtypes"})
public class BaseSuperServiceImpl< K extends MyJpaRepository<T,ID>, T extends SuperBaseModel,ID extends Serializable> implements BaseSuperService<T,ID> {
    protected Class<T> clazz;
    protected String keyName; //主键属性名
    protected Method getMethod; //得到主键对应的get方法
    protected String sortName="createTime"; //默认字段排序  由于个别表key为UUID，不能按key排序
    @Value("${isDebug}")
    protected boolean isDebug;
    @Autowired
    protected K dao;
    @Autowired
    protected StringRedisTemplate redisTemplate;
    @PersistenceContext
    protected EntityManager em;// 类似hibernate session
 
    public BaseSuperServiceImpl() {
        ParameterizedType type = (ParameterizedType) getClass().getGenericSuperclass();
        clazz = (Class<T>) type.getActualTypeArguments()[1];
        getMethod = HibernateUtil.getKeyMethod(clazz);
        String idname =getMethod.getName().substring(3);
        idname = idname.substring(0, 1).toLowerCase() + idname.substring(1);
        keyName = idname; //得到主键id名
    }
 
    @Override
    public List<T> findAll() {
        return dao.findAll();
    }
 
    @Override
    public List<T> findAll(Sort sort) {
        return dao.findAll(sort);
    }
 
    @Override
    public Page<T> findAll(Pageable pageable) {
        return dao.findAll(pageable);
    }
 
    @Override
    public List<T> findAll(Iterable<ID> integers) {
        return dao.findAll(integers);
    }
 
    @Override
    public long count() {
        return dao.count();
    }
 
    @Override
    public void delete(ID id) {
           dao.delete(id);
    }
 
    @Override
    public void delete(T entity) {
        dao.delete(entity);
    }
 
    @Override
    public void delete(Iterable<? extends T> entities) {
        dao.delete(entities);
    }
 
    @Override
    public void deleteAll() {
        dao.deleteAll();
    }
 
    @Override
    public <S extends T> S save(S entity) {
        try {
            SysUser curUser = WebUtil.getCurrentUser(isDebug);
            ID id = (ID) getMethod.invoke(entity);
            //如果新增，reateTime，createUserUUID没给值，统一赋值
            if(id==null){
                if(entity.getCreateTime()==null) entity.setCreateTime(DateUtil.getCurDate());
                if(entity.getCreateUserUUID()==null) entity.setCreateUserUUID(curUser.getUserUUId());
            }
            return dao.save(entity);
        } catch (Exception e) {
            LogerHelper.error(e);
        }
        return null;
    }
 
    @Override
    public <S extends T> List<S> save(Iterable<S> entities) {
        return dao.save(entities);
    }
 
    @Override
    public T findOne(ID id) {
        return dao.findOne(id);
    }
 
    @Override
    public boolean exists(ID id) {
        return dao.exists(id);
    }
 
    @Override
    public void flush() {
       dao.flush();
    }
 
    @Override
    public <S extends T> S saveAndFlush(S entity) {
        return dao.saveAndFlush(entity);
    }
 
    @Override
    public void deleteInBatch(Iterable<T> entities) {
        dao.deleteInBatch(entities);
    }
 
    @Override
    public void deleteAllInBatch() {
       dao.deleteAllInBatch();
    }
 
    @Override
    public T getOne(ID id) {
        return dao.getOne(id);
    }
 
    @Override
    public <S extends T> S findOne(Example<S> example) {
        return dao.findOne(example);
    }
 
    @Override
    public <S extends T> List<S> findAll(Example<S> example) {
        return dao.findAll(example);
    }
 
    @Override
    public <S extends T> List<S> findAll(Example<S> example, Sort sort) {
        return dao.findAll(example,sort);
    }
 
    @Override
    public <S extends T> Page<S> findAll(Example<S> example, Pageable pageable) {
        return dao.findAll(example, pageable);
    }
 
    @Override
    public <S extends T> long count(Example<S> example) {
        return dao.count(example);
    }
 
    @Override
    public <S extends T> boolean exists(Example<S> example) {
        return dao.exists(example);
    }
 
    @Override
    public PageResult<T> pagedList(T entity, Integer currentPage, Integer pageSize, Order... orders) {
        Sort s = null;
        if (orders != null && orders.length > 0) {
            s = new Sort(orders);
        } else {
            s = new Sort(new Order(Direction.DESC, sortName));
        }
        PageRequest pr = new PageRequest(currentPage - 1, pageSize, s);
        
        Page<T> p =  this.findAll(pr);
        Integer fromItem = PageUtil.getOffset(currentPage, pageSize);
        return new PageResult<T>(currentPage, pageSize, p.getContent(), (int)p.getTotalElements(), p.getTotalPages(), fromItem,  p.getContent().size());
    }
    
    @Override
    public PageResult<T> pagedList(T entity, Integer currentPage, Order... orders) {
         return this.pagedList(entity, currentPage,PageUtil.PAGE_SIZE,orders);    
    }
    
    
    protected List<Map> exectSqlMap(Query query) {
        query.unwrap(SQLQuery.class).setResultTransformer(Transformers.ALIAS_TO_ENTITY_MAP);
        return query.getResultList();
    }
    
    protected Map exectSqlMap2(Query query) {
        List<Map> list = exectSqlMap(query);
        return ListUtil.notEmpty(list)?list.get(0):null;
    }
    
    
    protected PageResult<T> gerPageResult(Integer currentPage, Integer pageSize, 
            Specification<T> sf,Order... orders) {
        //构建分页信息
        Sort s = null;
        if (orders != null && orders.length > 0) {
            s = new Sort(orders);
        } else {
            s = new Sort(new Order(Direction.DESC, sortName));
        }
        PageRequest pr = new PageRequest(currentPage - 1, pageSize, s);
        Page<T> p = sf==null?this.findAll(pr):this.findAll(sf,pr);
        Integer fromItem = PageUtil.getOffset(currentPage, pageSize);
        return new PageResult<T>(currentPage, pageSize, p.getContent(), (int)p.getTotalElements(), p.getTotalPages(), fromItem, p.getContent().size());
    }
 
    @Override
    public T findOne(Specification<T> spec) {
        return dao.findOne(spec);
    }
 
    @Override
    public List<T> findAll(Specification<T> spec) {
        return dao.findAll(spec);
    }
 
    @Override
    public Page<T> findAll(Specification<T> spec, Pageable pageable) {
        return dao.findAll(spec, pageable);
    }
 
    @Override
    public List<T> findAll(Specification<T> spec, Sort sort) {
        return dao.findAll(spec, sort);
    }
 
    @Override
    public long count(Specification<T> spec) {
        return dao.count(spec);
    }
 
 
    
}

基本上，重写了所有的方法。

然后创建：BaseServiceImpl

public class BaseServiceImpl<K extends MyJpaRepository<T,ID>,T extends BaseModel,ID extends Serializable> extends BaseSuperServiceImpl<K,T,ID> implements BaseService<T,ID> {
 
    @Override
    public PageResult<T> pagedListForVaild(T entity, Integer currentPage, Integer pageSize, Order... orders) throws Exception {
        Sort s = null;
        if (orders != null && orders.length > 0) {
            s = new Sort(orders);
        } else {
            s = new Sort(new Order(Direction.DESC, sortName));
        }
        PageRequest pr = new PageRequest(currentPage - 1, pageSize, s);
        T model = clazz.newInstance();
        model.setIsValid(EnumList.ValidEnum.Valid.getEnumItem().getItemKey());
        Example<T> example = Example.of(model);
        Page<T> p =  dao.findAll(example, pr);
        Integer fromItem = PageUtil.getOffset(currentPage, pageSize);
        return new PageResult<T>(currentPage, pageSize, p.getContent(), (int)p.getTotalElements(), p.getTotalPages(), fromItem,  p.getContent().size());
    
    }
 
    @Override
    public <S extends T> S save(S entity) {
        //如果isValid没给值，统一赋值
        if(entity.getIsValid()==null) entity.setIsValid(EnumList.ValidEnum.Valid.getEnumItem().getItemKey());
        return super.save(entity);
    }
 
    @Override
    public PageResult<T> pagedListForVaild(T entity, Integer currentPage, Order... orders) throws Exception {
        return this.pagedListForVaild(entity, currentPage,PageUtil.PAGE_SIZE,orders);
    }
    
}

最后创建UserServiceImpl

@Service("userService")
public class SysUserServiceImpl extends BaseServiceImpl<SysUserDao,SysUser,String>  implements SysUserService {
 
    public SysUser getByUserUUId(String userUUId){
        return  dao.getByUserUUId(userUUId);
 
    }
    @Override
    public SysUser getByAccountAndPlatformUUID(String account,String platformUUID) {
        return dao.getByAccountAndPlatformUUID(account,platformUUID);
    }
    @Override
    public SysUser getByAccount(String account) {
        return dao.getByAccount(account);
    }
 
    @Override
    public PageResult<SysUser> pagedList(SysUser entity, Integer currentPage, Integer pageSize, Order... orders) {
        if(entity==null){
            return super.pagedList(entity, currentPage, pageSize, orders);
        }
        
        //构建查询条件
        Specification<SysUser> sf = new Specification<SysUser>(){
            @Override
            public Predicate toPredicate(Root<SysUser> root, CriteriaQuery<?> query, CriteriaBuilder cb) {
                String name = entity.getUserNameCn();
                Integer isValid = entity.getIsValid();
                List<Predicate> list = new ArrayList<Predicate>();
                if (StringUtils.isNotBlank(name)) {
                    name = name.toLowerCase();
                    Predicate p1 = cb.like(cb.lower(root.get("userNameCn")), "%" + name + "%");
                    Predicate p2 = cb.like(cb.lower(root.get("userNameEn")), "%" + name + "%");
                    Predicate p3 = cb.like(cb.lower(root.get("account")), "%" + name+ "%");
                    list.add(cb.or(p1,p2,p3));
                }
                if(isValid!=null){
                    list.add(cb.equal(root.get("isValid"),isValid));
                }
                Predicate[] p = new Predicate[list.size()];
                return cb.and(list.toArray(p));
            }
        };
        
        return super.gerPageResult(currentPage, pageSize,sf,orders);
    
    }
    
    
    
}

这里，我额外演示一下重写了PagedList方法。

四，测试调用

@RunWith(value=SpringRunner.class)
@SpringBootTest(classes={WebAPISYSApp.class})
public class SysUserTest{
    @Autowired
    private SysUserService userService;
 
    @Test
    public void findUser(){
        SysUser user = userService.findOne("0c867aca-d1eb-11e8-9aa5-0022198292f8");
        logger.info(user.getAccount());
        
    }
    
}