spring data jpa 之 通用接口
2024-10-09 11:19:06
园主这一阵子接到一个需求，就是将spring data jpa再进行封装，实现通过调用一个baseRepository，来实现每个类的增删改查操作，结合spring data jpa 原有的便捷操作，实现快捷开发，话不多说，上代码！
1 首先编写通用接口
package com.hhsj.repository; import com.hhsj.base.Params;
import com.hhsj.base.Result;
import org.springframework.data.jpa.repository.JpaRepository; import java.util.LinkedHashMap;
import java.util.List; public interface baseRepository<T ,ID>{ /**
* 保存数据对象
* @param entity
* @return
*/
Boolean save(T entity);
/**
* 根据id查询
* @param clazz
* @param id
* @return
*/
T findByid(Class<T> clazz,ID id);
/**
* 根据表名，字段，参数查询，拼接sql语句
* @param clazz 表的class
* @param filed 字段名
* @param o 字段参数
* @return
*/
List<T> findByField(Class<T> clazz, String filed, Object o); /**
* 多个字段的查询
* @param clazz 表的class
* @param map 将你的字段传入map中
* @return
*/
List<T> findByMoreFiled(Class<T> clazz,LinkedHashMap<String,Object> map); /**
* 根据表的id删除数据
* @param entity
*/
Boolean delete(T entity);
/**
* 更新对象
* @param e
* @return
*/
Boolean update(T e ,ID id);
/**
* 根据条件查询总条数返回object类型
* @param clazz 表的class
* @param map 传入参数放入map中
* @return
*/
Integer findCount(Class<T> clazz, LinkedHashMap<String,Object> map); /**
* 通过传入自定义参数查询
* @param clazz
* @param params
* @return
*/
List<T> findByParams(Class<T> clazz , Params params); /**
* 根据id删除
* @param clazz
* @param id
* @return
*/
Boolean deleteById(Class<T> clazz, ID id); /**
* 通过id集合批量删除
* @param clazz
* @param ids
* @return
*/
Boolean deleteByIds(Class<T> clazz , List<ID> ids);
}
BaseRepository
2 通用接口的实现类
package com.hhsj.repository; import com.hhsj.base.BeanUtils;
import com.hhsj.base.Params;
import org.springframework.stereotype.Repository;
import javax.persistence.EntityManager;
import javax.persistence.PersistenceContext;
import javax.persistence.Query;
import javax.transaction.Transactional;
import java.lang.reflect.Field;
import java.util.*; @Repository
public class BaseRepositoryImpl<T,ID> implements baseRepository<T,ID>{ @PersistenceContext
private EntityManager entityManager; @Override
@Transactional
public Boolean save(T entity){
boolean flag = false;
try {
entityManager.persist(entity);
flag = true;
}catch (Exception e){
System.out.println("---------------保存出错---------------");
e.printStackTrace();
}
return flag;
} @Override
public T findByid(Class<T> clazz,ID id) {
T t = null;
try {
t = entityManager.find(clazz, id);
} catch (Exception e) {
System.out.println("---------------查询出错---------------");
e.printStackTrace();
}
return t;
} @Override
public List<T> findByField(Class<T> clazz, String filed, Object value ) {
String tablename = clazz.getName();
List<T> list = new ArrayList<>();
try {
String sql="from "+tablename+" u WHERE u."+filed+"=?1";
Query query=entityManager.createQuery(sql);
query.setParameter(1,value);
list= query.getResultList();
entityManager.close();
}catch (Exception e){
System.out.println("---------------查询出错---------------");
e.printStackTrace();
}
return list;
} @Override
@Transactional
public Boolean deleteById(Class<T> clazz, ID id) {
Boolean flag = false;
try {
String tableName = clazz.getName();
String sql = "delete from "+tableName+" u WHERE u.id = ?1";
Query query=entityManager.createQuery(sql);
query.setParameter(1,id);
int i = query.executeUpdate();
if(i != 0){
flag = true;
}
entityManager.close();
} catch (Exception e) {
e.printStackTrace();
} return flag;
} @Override
@Transactional
public Boolean deleteByIds(Class<T> clazz, List<ID> ids) {
boolean flag = false;
List<ID> param = new ArrayList<ID>();
int index = 1;
try {
String tableName = clazz.getName();
StringBuilder sql = new StringBuilder("delete from "+tableName+" u WHERE u.id in (");
if (ids != null && ids.size() != 0){
for (ID id : ids) {
sql.append("?").append(index).append(",");
param.add(id);
index ++ ;
}
}
sql.deleteCharAt(sql.length() - 1 );
sql.append(")");
Query query=entityManager.createQuery(sql.toString());
for (int x = 0;x < param.size();x++) {
query.setParameter(x+1,param.get(x));
}
int i = query.executeUpdate();
if (i != 0){
flag = true;
}
entityManager.close();
} catch (Exception e) {
e.printStackTrace();
}
return flag;
} @Override
public List<T> findByMoreFiled(Class<T> clazz,LinkedHashMap<String,Object> map) {
String tablename = clazz.getName();
List<T> listRe = new ArrayList<>();
try {
String sql="from "+tablename+" u WHERE ";
Set<String> set=null;
set=map.keySet();
List<String> list=new ArrayList<>(set);
List<Object> filedlist=new ArrayList<>();
int x = 1;
for (String filed:list){
sql+="u."+filed+"=?"+x+" and ";
filedlist.add(filed);
x++;
}
sql=sql.substring(0,sql.length()-4);
Query query=entityManager.createQuery(sql);
for (int i=0;i<filedlist.size();i++){
query.setParameter(i+1,map.get(filedlist.get(i)));
}
listRe= query.getResultList();
entityManager.close();
}catch (Exception e){
System.out.println("---------------查询出错---------------");
e.printStackTrace();
}
return listRe;
} @Override
@Transactional
public Boolean update(T entity,ID id) {
boolean flag = false;
try {
Object o = entityManager.find(entity.getClass(), id);
BeanUtils.copyPropertiesExcludeNull(entity,o);
entityManager.merge(o);
flag = true;
} catch (Exception e) {
System.out.println("---------------查询出错---------------");
e.printStackTrace();
}
return flag;
} @Override
@Transactional
public Boolean delete(T entity) { //entity通过设置id来删除相应数据
boolean flag=false;
try {
entityManager.remove(entityManager.merge(entity));
flag=true;
}catch (Exception e){
System.out.println("---------------删除出错---------------");
e.printStackTrace();
}
return flag;
} @Override
public Integer findCount(Class<T> clazz, LinkedHashMap<String, Object> map) {
String tablename = clazz.getName();
Query query= null;
Object count = 0;
try {
String sql="select count(u) from "+tablename+" u WHERE ";
Set<String> set=null;
set=map.keySet();
List<String> list=new ArrayList<>(set);
List<Object> filedlist=new ArrayList<>();
int x = 1;
for (String filed:list){
sql+="u."+filed+"=?"+ x +" and ";
x++;
filedlist.add(filed);
}
sql=sql.substring(0,sql.length()-4);
query = entityManager.createQuery(sql);
for (int i=0;i<filedlist.size();i++){
query.setParameter(i+1,map.get(filedlist.get(i)));
}
count = query.getSingleResult();
} catch (Exception e) {
System.out.println("---------------查询出错---------------");
e.printStackTrace();
}
return Integer.parseInt(count.toString());
} @Override
public List<T> findByParams(Class<T> clazz, Params params) {
String tablename = clazz.getName();
List<T> listRe = new ArrayList<>();
//jpa运行时需要的参数
List param = new ArrayList();
try {
StringBuilder sql = new StringBuilder();
sql.append("from ").append(tablename).append(" u WHERE 1=1 ");
int index = 0;
//拼接sql，添加参数集合
index = concatSqlForObj(index,param, sql, params.getAnd(), params.getAndPara());
index = concatSqlForObj(index,param, sql, params.getOr(), params.getOrPara());
index = concatSqlForList(index,param, sql, params.getBetween(), params.getBetweenPara());
index = concatSqlForObj(index,param, sql, params.getLessThan(), params.getLessThanPara());
index = concatSqlForObj(index,param, sql, params.getMoreThan(), params.getMoreThanPara());
index = concatSqlForObj(index,param, sql, params.getLike(), params.getLikePara());
index = concatSqlForObj(index,param, sql, params.getNotLike(), params.getNotLikePara());
index = concatSqlForObj(index,param, sql, params.getOrderBy(), params.getOrderByPara());
index = concatSqlForObj(index,param, sql, params.getNot(), params.getNotPara()); index = concatSqlForList(index,param, sql, params.getIn(), params.getInPara());
index = concatSqlForList(index,param, sql, params.getNotIn(), params.getNotInPara()); Query query=entityManager.createQuery(sql.toString());
//limit
if (params.getLimitPara() != null){
List list = params.getLimitPara().get("limit");
query.setFirstResult((Integer) list.get(0));
query.setMaxResults((Integer) list.get(1));
}
for (int i=0;i<param.size();i++){
query.setParameter(i+1,param.get(i));
}
listRe= query.getResultList();
entityManager.close();
}catch (Exception e){
System.out.println("---------------查询出错---------------");
e.printStackTrace();
}
return listRe;
} public static int concatSqlForObj(int index,List param ,StringBuilder sql , List<String> symbols , LinkedHashMap<String , Object> params){
//拼接sql时需要的参数索引
int index1 = index;
//取list中的键值对是需要的索引
int x = 0;
if (symbols != null && symbols.size() != 0){
for (String symbol: symbols) {
//通过转换list获取键值对
List<Map.Entry<String, Object>> indexedList = new ArrayList<Map.Entry<String, Object>>(params.entrySet());
Map.Entry<String, Object> entry = indexedList.get(x);
String key = entry.getKey();
Object value = entry.getValue(); index1 ++ ;
x++; if (symbol.equals("or")){
sql.append(" or u.").append(key).append("=?").append(index1);
}else if(symbol.equals("<")){
sql.append(" and u.").append(key).append("<?").append(index1);
}else if(symbol.equals(">")){
sql.append(" and u.").append(key).append(">?").append(index1);
}else if(symbol.equals("like")){
sql.append(" and u.").append(key).append(" like ?").append(index1);
}else if(symbol.equals("notlike")){
sql.append(" and u.").append(key).append(" not like ?").append(index1);
}else if(symbol.equals("!=")){
sql.append(" and u.").append(key).append(" != ?").append(index1);
}
else if(symbol.equals("orderby")){
//val的值可取asc 和 desc
sql.append(" ORDER BY ").append(key).append(" ").append(value.toString());
return index1;
}
else {
sql.append(" and u."+key + symbol+"?" + index1);
}
param.add(value);
}
}
return index1;
} public static int concatSqlForList(int index,List param ,StringBuilder sql , List<String> symbols , LinkedHashMap<String , List> params){
//拼接sql时需要的参数索引
int index1 = index;
//取list中的键值对是需要的索引
int x = 0;
if (symbols != null && symbols.size() != 0){
for (String symbol: symbols) {
//通过转换list获取键值对
List<Map.Entry<String, List>> indexedList = new ArrayList<Map.Entry<String, List>>(params.entrySet());
Map.Entry<String, List> entry = indexedList.get(x);
String key = entry.getKey();
List value = entry.getValue(); index1 ++ ;
x++; if(symbol.equals("between")){
sql.append(" and u.").append(key).append(" between ?").append(index1).append(" and ?").append(index1 + 1);
index1 ++;
}else if (symbol.equals("in") || symbol.equals("notin")){
sql.append(" and u.").append(key);
if (symbol.equals("in")){
sql.append(" in (?");
}else {
sql.append(" not in (?");
}
sql.append(index1);
param.add(value.get(0));
for (int i = 1 ; i < value.size() ; i++){
index1 ++;
sql.append(",?").append(index1);
param.add(value.get(i));
}
sql.append(")");
return index1;
}
param.add(value.get(0));
param.add(value.get(1));
}
}
return index1;
}
}
BaseRepositoryImpl
3 多条件查询的参数类
package com.hhsj.base; import lombok.Data; import java.util.ArrayList;
import java.util.List;
import java.util.LinkedHashMap; /**
* 自定义参数
*/
@Data
public class Params { private final List<String> and;
private final LinkedHashMap<String ,Object> andPara; private final List<String> or;
private final LinkedHashMap<String ,Object> orPara; private final List<String> between;
private final LinkedHashMap<String ,List> betweenPara; private final List<String> lessThan;
private final LinkedHashMap<String ,Object> lessThanPara; private final List<String> moreThan;
private final LinkedHashMap<String ,Object> moreThanPara; /* private final List<String> isNull;
private final LinkedHashMap<String ,Object> isNullPara; private final List<String> isNotNull;
private final LinkedHashMap<String ,Object> isNotNullPara;*/ private final List<String> like;
private final LinkedHashMap<String ,Object> likePara; private final List<String> notLike;
private final LinkedHashMap<String ,Object> notLikePara; private final List<String> orderBy;
private final LinkedHashMap<String ,Object> orderByPara; private final List<String> not;
private final LinkedHashMap<String ,Object> notPara; private final List<String> in;
private final LinkedHashMap<String ,List> inPara; private final List<String> notIn;
private final LinkedHashMap<String ,List> notInPara; private final List<String> limit;
private final LinkedHashMap<String ,List> limitPara; private Params(Bulider bulider){
this.and = bulider.and;
this.andPara = bulider.andPara;
this.or = bulider.or;
this.orPara = bulider.orPara;
this.between = bulider.between;
this.betweenPara = bulider.betweenPara;
this.lessThan = bulider.lessThan;
this.lessThanPara = bulider.lessThanPara;
this.moreThan = bulider.moreThan;
this.moreThanPara = bulider.moreThanPara;
/*this.isNull = bulider.isNull;
this.isNullPara = bulider.isNullPara;
this.isNotNull = bulider.isNotNull;
this.isNotNullPara = bulider.isNotNullPara;*/
this.like = bulider.like;
this.likePara = bulider.likePara;
this.notLike = bulider.notLike;
this.notLikePara = bulider.notLikePara;
this.orderBy = bulider.orderBy;
this.orderByPara = bulider.orderByPara;
this.not = bulider.not;
this.notPara = bulider.notPara;
this.in = bulider.in;
this.inPara = bulider.inPara;
this.notIn = bulider.notIn;
this.notInPara = bulider.notInPara;
this.limit = bulider.limit;
this.limitPara = bulider.limitPara;
} public static Params.Bulider builder() {
return new Params.Bulider();
} public static class Bulider{
private List<String> and;
private LinkedHashMap<String ,Object> andPara; private List<String> or;
private LinkedHashMap<String ,Object> orPara; private List<String> between;
private LinkedHashMap<String ,List> betweenPara; private List<String> lessThan;
private LinkedHashMap<String ,Object> lessThanPara; private List<String> moreThan;
private LinkedHashMap<String ,Object> moreThanPara; /* private List<String> isNull;
private LinkedHashMap<String ,Object> isNullPara; private List<String> isNotNull;
private LinkedHashMap<String ,Object> isNotNullPara;*/ private List<String> like;
private LinkedHashMap<String ,Object> likePara; private List<String> notLike;
private LinkedHashMap<String ,Object> notLikePara; private List<String> orderBy;
private LinkedHashMap<String ,Object> orderByPara; private List<String> not;
private LinkedHashMap<String ,Object> notPara; private List<String> in;
private LinkedHashMap<String ,List> inPara; private List<String> notIn;
private LinkedHashMap<String ,List> notInPara; private List<String> limit;
private LinkedHashMap<String ,List> limitPara; public Bulider Euqal(String key , Object value){
this.and = new ArrayList<>();
this.andPara = new LinkedHashMap<>();
this.and.add("=");
this.andPara.put(key,value);
return this;
} public Bulider Or(String key , Object value){
this.or = new ArrayList<>();
this.orPara = new LinkedHashMap<>();
this.or.add("or");
this.orPara.put(key,value);
return this;
} public Bulider Between(String key , Object value1 , Object value2){
this.between = new ArrayList<>();
this.betweenPara = new LinkedHashMap<>();
List value = new ArrayList();
value.add(value1);
value.add(value2);
this.between.add("between");
this.betweenPara.put(key,value);
return this;
} public Bulider LessThan(String key , Object value){
this.lessThan = new ArrayList<>();
this.lessThanPara = new LinkedHashMap<>();
this.lessThan.add("<");
this.lessThanPara.put(key,value);
return this;
} public Bulider MoreThan(String key , Object value){
this.moreThan = new ArrayList<>();
this.moreThanPara = new LinkedHashMap<>();
this.moreThan.add(">");
this.moreThanPara.put(key,value);
return this;
} /*public Bulider IsNull(String key , Object value){
this.isNull = new ArrayList<>();
this.isNullPara = new LinkedHashMap<>();
this.isNull.add("isnull");
this.isNullPara.put(key,value);
return this;
} public Bulider IsNotNull(String key , Object value){
this.isNotNull = new ArrayList<>();
this.isNotNullPara = new LinkedHashMap<>();
this.isNotNull.add("isnotnull");
this.isNotNullPara.put(key,value);
return this;
}*/ public Bulider Like(String key , Object value){
this.like = new ArrayList<>();
this.likePara = new LinkedHashMap<>();
this.like.add("like");
this.likePara.put(key,value);
return this;
} public Bulider NotLike(String key , Object value){
this.notLike = new ArrayList<>();
this.notLikePara = new LinkedHashMap<>();
this.notLike.add("notlike");
this.notLikePara.put(key,value);
return this;
} public Bulider OrderBy(String key , Object value){
this.orderBy = new ArrayList<>();
this.orderByPara = new LinkedHashMap<>();
this.orderBy.add("orderby");
this.orderByPara.put(key,value);
return this;
} public Bulider NotEqual(String key , Object value){
this.not = new ArrayList<>();
this.notPara = new LinkedHashMap<>();
this.not.add("!=");
this.notPara.put(key,value);
return this;
} public Bulider In(String key , Object ... values){
this.in = new ArrayList<>();
this.inPara = new LinkedHashMap<>();
List list = new ArrayList();
for (Object value : values) {
list.add(value);
}
this.in.add("in");
this.inPara.put(key,list);
return this;
} public Bulider NotIn(String key , Object ... values){
this.notIn = new ArrayList<>();
this.notInPara = new LinkedHashMap<>();
List list = new ArrayList();
for (Object value : values) {
list.add(value);
}
this.notIn.add("notin");
this.notInPara.put(key,list);
return this;
} public Bulider Limit(Integer value1 , Integer value2){
this.limit = new ArrayList<>();
this.limitPara = new LinkedHashMap<>();
List<Integer> list = new ArrayList();
list.add(value1);
list.add(value2);
this.limit.add("limit");
this.limitPara.put("limit",list);
return this;
} public Params build() {
return new Params(this);
}
} }
Params
4 我的测试类
package com.hhsj.controller; import com.hhsj.base.Params;
import com.hhsj.base.Result;
import com.hhsj.entity.DevUser;
import com.hhsj.repository.BaseRepositoryImpl;
import com.hhsj.service.impl.DevUserServiceImpl;
import com.sun.org.apache.xml.internal.security.keys.keyresolver.implementations.PrivateKeyResolver;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController; import java.util.*; @RestController
public class UserController {
@Autowired
private BaseRepositoryImpl baseRepository; @GetMapping("/cs/save")
public Boolean csSave(){
DevUser devUser = new DevUser();
devUser.setUsername("xxasdasdasdasdasdasdasd");
devUser.setPassword("dddfadadadasdasd");
return baseRepository.save(devUser);
} @GetMapping("/cs/findById")
public DevUser csF(){
return (DevUser) baseRepository.findByid(DevUser.class,5);
} @GetMapping("/cs/delbyid")
public Boolean csDelById(){
return baseRepository.deleteById(DevUser.class,5);
} @GetMapping("/cs/findByField")
public List<DevUser> csFindByField(){
return baseRepository.findByField(DevUser.class,"username","1");
} @GetMapping("/cs/delByIds")
public boolean csdelByIds(){
List<Integer> list = new ArrayList<>();
list.add(8);
list.add(9);
return baseRepository.deleteByIds(DevUser.class,list);
} @GetMapping("/cs/findByFields")
public List<DevUser> csFindByFields(){
LinkedHashMap map = new LinkedHashMap();
map.put("username","12");
map.put("password","dddf");
return baseRepository.findByMoreFiled(DevUser.class,map);
} @GetMapping("/cs/del")
public Boolean csDel(){
DevUser devUser = new DevUser();
devUser.setId(6);
return baseRepository.delete(devUser);
} @GetMapping("/cs/upd")
public Boolean csUpd(){
DevUser devUser = new DevUser();
devUser.setId(3);
devUser.setUsername("123345567qweqwwwqe");
devUser.setPassword("asdaslkdaksdfviosdhfgsdbfkjhdasiofhasdfbdasihgo");
return baseRepository.update(devUser,devUser.getId());
} @GetMapping("/cs/getCount")
public Integer csgetCount(){
LinkedHashMap map = new LinkedHashMap();
map.put("username","1");
return baseRepository.findCount(DevUser.class,map);
} @GetMapping("/cs/findByParm")
public List<DevUser> csfindByParm(){
Params build = Params.builder().Euqal("password","wqeq").Like("username","%q%").OrderBy("id","desc").build();
return baseRepository.findByParams(DevUser.class, build);
}
}
UserController
4 yml文件
spring:
datasource:
url: jdbc:mysql://localhost:3306/test
username: root
password: 12345
driver-class-name: com.mysql.jdbc.Driver
jpa:
show-sql: true
4 附上通用的Result
package com.hhsj.base; import com.fasterxml.jackson.annotation.JsonIgnore;
import com.fasterxml.jackson.annotation.JsonIgnoreProperties;
import lombok.Data; /**
* @author cnyuchu@gmail.com
* @date 2018/11/8 9:27
*/
@Data
public class Result<T> { private final String result; private final Integer code; private final String message; private final T data; private Result(Builder<T> builder) {
this.result = builder.result;
this.code = builder.code;
this.message = builder.message;
this.data = builder.data;
} public static<T> Result.Builder<T> builder() {
return new Result.Builder<>();
} public static class Builder<T> {
private String result; private Integer code; private String message; private T data; public Builder<T> code(Integer code) {
this.code = code;
return this;
} public Builder<T> message(String message) {
this.message = message;
return this;
} public Builder<T> result(String result) {
this.result = result;
return this;
} public Builder<T> success() {
this.result = "SUCCESS";
this.code = 200;
return this;
} public Builder<T> fail() {
this.result = "FAILURE";
this.code = 500;
return this;
} public Builder<T> data(T data) {
this.data = data;
return this;
} public Result<T> build() {
return new Result<>(this);
}
} @JsonIgnore
public Boolean isFailed(){
return this.code==500;
}
}
Result
5 自定义的beanUtils工具类，可复制不为null的属性
package com.hhsj.base; import org.springframework.beans.BeanWrapper;
import org.springframework.beans.BeanWrapperImpl;
import org.springframework.beans.BeansException; import java.util.HashSet;
import java.util.Set; /**
* BeanUtils
*
* @author zhuyoufeng
*/
public class BeanUtils extends org.springframework.beans.BeanUtils { public static String[] getNullPropertyNames(Object source) {
final BeanWrapper src = new BeanWrapperImpl(source);
java.beans.PropertyDescriptor[] pds = src.getPropertyDescriptors(); Set<String> emptyNames = new HashSet<String>();
for (java.beans.PropertyDescriptor pd : pds) {
Object srcValue = src.getPropertyValue(pd.getName());
if (srcValue == null) emptyNames.add(pd.getName());
}
String[] result = new String[emptyNames.size()];
return emptyNames.toArray(result);
} public static void copyPropertiesExcludeNull(Object source, Object target) throws BeansException {
org.springframework.beans.BeanUtils.copyProperties(source, target, getNullPropertyNames(source));
}
}
BeanUtils
今天的代码就这么多了，有问题一起探讨，谢谢各位。
qq :1508952532
最新文章
- window10的优缺点
- lua表排序
- java中IO流相关知识点
- Linux安装mysql最新版本纪要
- 向Web开发人员推荐12款优秀的 Twitter Bootstrap 组件和工具
- Correlation Filter in Visual Tracking系列二：Fast Visual Tracking via Dense Spatio-Temporal Context Learning 论文笔记
- C#和ASP.Net面试题目集锦
- Effective C++_笔记_条款02_尽量以const、enum、inline替换#define
- Linux：闪光的宝石，智慧 (在）
- cocos2dx android resources.ap_ does not exist
- poj_2186: Popular Cows（tarjan基础题）
- HTML篇(下·)
- 如何为Web应用选择托管主机
- python_练习04
- Hadoop学习笔记（六）：hive使用
- docker搭建lnmp环境
- 【论文阅读】Deep Adversarial Subspace Clustering
- html中hr的各种样式使用
- Linux 64位 CentOS下安装 Docker 容器，启动、停止
- caioj 1172 poj 2823 单调队列过渡题