weixin_34364071
weixin_34364071

JSqlParser基本应用文档-select部分

2019独角兽企业重金招聘Python工程师标准>>> hot3.png

JSqlParser基本应用文档

该文档旨在快速了解JSqlParser的基本结构设计和JSqlParser中的select部分的应用(alter、delete、insert等其他部分视具体情况而定)。主要从普通查询（select）、子查询（subselect）、连接查询（union select）三个方面来了解JSqlParser的直接调用和SelectObject（已封装）的调用两个方面来简单构造。在构建sql之前先了解下JSqlParser的基本构造。

JSqlParser组成部分：

  

selectBody结构：

 

 

 

 

 

 

  

基本应用

基础数据：

直销客户业务量汇总：KB_ZX_CUST_PROD_SUM

字段

名称

month

统计月份

VIP_TYPE

客户类型

ZX_CUST_CODE

直销客户编码

ZX_CUST_NAME

直销客户名称

CUST_SUBST_NAME

客户局向

SUM_TOTAL

全部总用户数

 

生成表别名：

selectObject.generateTableAlias(key, tableName, aliasName);

等价于

selectObject.generateTableAlias(key, tableName, aliasName,false);

获取表别名：

selectObject.getTableAlias(key);

获取表：

selectObject.getTableByKey(key);

构造查询语句：

普通查询

条件设置

统计月份

12

客户类型

高值商客

直销客户编码

12

输出字段

统计月份

不使用函数

全部总用户数

不使用函数

目的SQL：

SELECT T_A.month, T_A.SUM_TOTAL  FROM KB_ZX_CUST_PROD_SUM T_A WHERE T_A.MONTH = '201512' AND  ( T_A.month = '12')  AND  ( T_A.VIP_TYPE = '高值商客')  AND  ( T_A.ZX_CUST_CODE = '12')

Demo：

package com.chinatmg.ecpp.helper;

 

import java.util.ArrayList;

import java.util.List;

 

import net.sf.jsqlparser.JSQLParserException;

import net.sf.jsqlparser.expression.Alias;

import net.sf.jsqlparser.expression.BinaryExpression;

import net.sf.jsqlparser.expression.CastExpression;

import net.sf.jsqlparser.expression.Expression;

import net.sf.jsqlparser.expression.Function;

import net.sf.jsqlparser.expression.LongValue;

import net.sf.jsqlparser.expression.Parenthesis;

import net.sf.jsqlparser.expression.StringValue;

import net.sf.jsqlparser.expression.operators.conditional.AndExpression;

import net.sf.jsqlparser.expression.operators.relational.EqualsTo;

import net.sf.jsqlparser.expression.operators.relational.ExpressionList;

import net.sf.jsqlparser.schema.Column;

import net.sf.jsqlparser.schema.Table;

import net.sf.jsqlparser.statement.create.table.ColDataType;

import net.sf.jsqlparser.statement.select.AllColumns;

import net.sf.jsqlparser.statement.select.Limit;

import net.sf.jsqlparser.statement.select.PlainSelect;

import net.sf.jsqlparser.statement.select.SelectExpressionItem;

 

import org.apache.commons.lang.StringUtils;

 

public class SimpleSelectDemo {

 

public static void main(String[] args){

SimpleSelectDemo demo = new SimpleSelectDemo();

String table= "KB_ZX_CUST_PROD_SUM";

String[][] condition ={{"MONTH","12"},{"VIP_TYPE","高值商客"},{"ZX_CUST_CODE","12"}};

String[][] outColumn = {{"MONTH"},{"SUM_TOTAL"}};

String limit = "122";

demo.selectObjectDemo(table, null,condition, outColumn,null,limit);

demo.jsqlDemo(table, null,condition, outColumn,null,limit);

}

 

//SelectObject使用

SelectObject selectObjectDemo(String table,String aliasName,String[][] condition,String[][] outColumn,String[][] groubyColumn,String limit){

if(aliasName==null){

aliasName="T_A";

}

SelectObject selectObject = new SelectObject();

//生成表别名，默认userAs为true

selectObject.generateTableAlias(table, table, aliasName);

//设置查询的主体

selectObject.setFromItem(selectObject.getTableByKey(table));

//加入查询字段

if(outColumn!=null){

for(String[] out:outColumn){

switch (out.length){

case 1:

selectObject.addSelectItem(aliasName+"."+out[0]);

break;

case 2:

selectObject.addSelectItem(out[1]+"("+aliasName+"."+out[0]+")");

break;

case 4:

selectObject.addSelectItem(out[1]+"("+out[2]+"("+aliasName+"."+out[0]+" as "+out[3]+"))");

break;

}

}

}else{

selectObject.addSelectItem("(*)");

}

//加入查询条件

if(condition!=null){

for(String[] cond:condition){

try {

selectObject.addWhereExpression("("+aliasName+"."+cond[0]+"='"+cond[1]+"')");

} catch (JSQLParserException e) {

e.printStackTrace();

}

}

}

//添加group by

if(groubyColumn!=null){

for(String[] group:groubyColumn){

selectObject.addGroupByExpression(aliasName+"."+group[0]);

}

}

//设置Limit

if(StringUtils.isNotEmpty(limit)){

selectObject.setLimit(limit);

}

System.out.println("selectObject:"+selectObject);

return selectObject;

}

 

//JSqlParser直接调用

PlainSelect jsqlDemo(String ta,String aliasName,String[][] condition,String[][] outColumn,String[][] groubyColumn,String rowCount){

if(aliasName==null){

aliasName="T_A";

}

PlainSelect plainSelect = new PlainSelect();

 

Table table = new Table(ta);

Alias alias = new Alias(aliasName);

table.setAlias(alias);

//设置查询的主体

plainSelect.setFromItem(table);

//加入查询字段

if(outColumn!=null){

SelectExpressionItem selectItem = null;

Expression selectExpression = null;

Function func = null;

List funcExpression = null;

CastExpression castExpression = null;

ColDataType colDataType = null;

for(String[] out:outColumn){

selectExpression = null;

selectItem = new SelectExpressionItem();

switch (out.length){

case 1:

selectExpression = new Column(aliasName+"."+out[0]);

break;

case 2:

func = new Function();

func.setName(out[1]);

funcExpression = new ArrayList();

funcExpression.add(new Column(aliasName+"."+out[0]));

func.setParameters(new ExpressionList(funcExpression));

selectExpression = func;

break;

case 4:

//此处以cast 为例

func = new Function();

func.setName(out[1]);

funcExpression = new ArrayList();

castExpression = new CastExpression();

castExpression.setLeftExpression(new Column(aliasName+"."+out[0]));

colDataType = new ColDataType();

colDataType.setDataType(out[3]);

castExpression.setType(colDataType);

castExpression.setUseCastKeyword(true);

funcExpression.add(castExpression);

func.setParameters(new ExpressionList(funcExpression));

selectExpression = func;

break;

}

selectItem.setExpression(selectExpression);

plainSelect.addSelectItems(selectItem);

}

}else{

plainSelect.addSelectItems(new AllColumns());

}

//加入查询条件

if(condition!=null){

BinaryExpression whereExpression =null;

for(String[] cond:condition){

whereExpression = new EqualsTo();

whereExpression.setLeftExpression(new Column(aliasName+"."+cond[0]));

whereExpression.setRightExpression(new StringValue(cond[1]));

if(plainSelect.getWhere()==null){

plainSelect.setWhere(new Parenthesis(whereExpression));

}else{

plainSelect.setWhere(new AndExpression(plainSelect.getWhere(),new Parenthesis(whereExpression)));

}

}

}

//添加group by

if(groubyColumn!=null){

for(String[] group:groubyColumn){

plainSelect.addGroupByColumnReference(new Column(aliasName+"."+group[0]));

}

}

//设置Limit

if(StringUtils.isNotEmpty(rowCount)){

Limit limit = new Limit();

limit.setRowCount(new LongValue(rowCount));

plainSelect.setLimit(limit);

}

System.out.println("JSqlDemo:"+plainSelect);

return plainSelect;

}

}

 

 

 

子查询:基于普通查询

条件设置

统计月份

12

客户类型

高值商客

直销客户编码

12

分组维度

直销客户名称

 

客户局向

 

输出字段

统计月份

统计

全部总用户数

求和

目的SQL：

select COUNT(a.month), SUM(CAST(a.SUM_TOTAL as double)), a.ZX_CUST_NAME, a.CUST_SUBST_NAME from (SELECT T_A.month, T_A.SUM_TOTAL, T_A.ZX_CUST_NAME, T_A.CUST_SUBST_NAME FROM KB_ZX_CUST_PROD_SUM T_A WHERE  ( T_A.month = '12') AND ( T_A.VIP_TYPE = '高值商客') AND ( T_A.ZX_CUST_CODE = '12') AND ( ( T_A.ZX_CUST_CODE = '3232') AND ( T_A.CUST_SUBST_NAME = '23') ) ) a group by a.ZX_CUST_NAME, a.CUST_SUBST_NAME limit 122

Demo:

package com.chinatmg.ecpp.helper;

 

import net.sf.jsqlparser.expression.Alias;

import net.sf.jsqlparser.statement.select.PlainSelect;

import net.sf.jsqlparser.statement.select.SubSelect;

 

public class SimpleSubselectDemo {

public static void main(String[] args){

String table= "KB_ZX_CUST_PROD_SUM";

String[][] condition ={{"MONTH","12"},{"VIP_TYPE","高值商客"},{"ZX_CUST_CODE","12"}};

String[][] outColumn = {{"MONTH","COUNT"},{"SUM_TOTAL","SUM","CAST","double"},{"ZX_CUST_NAME"},{"CUST_SUBST_NAME"}};

String[][] groubyColumn = {{"MONTH"},{"SUM_TOTAL"}};

//子查询输出的字段

String[][] suboutColumn = {{"MONTH"},{"SUM_TOTAL"},{"ZX_CUST_NAME"},{"CUST_SUBST_NAME"}};

String limit = "122";

SimpleSubselectDemo demo= new SimpleSubselectDemo();

demo.suselectObjectDemo(table, condition, outColumn, groubyColumn, suboutColumn,limit);

demo.jsqlDemo(table, condition, outColumn, groubyColumn, suboutColumn,limit);

}

 

//SelectObject使用

SelectObject suselectObjectDemo(String table,String[][] condition,String[][] outColumn,String[][] groubyColumn,String[][] suboutColumn,String limit){

SimpleSelectDemo demo = new SimpleSelectDemo();

SelectObject selectObject = demo.selectObjectDemo("a", "a", null, outColumn, groubyColumn, limit);

SelectObject subselectObject = demo.selectObjectDemo(table,null, condition, suboutColumn,null,null);

selectObject.setSubselectObject(subselectObject, "a", false);;

System.out.println("subselect:"+selectObject);

return selectObject;

}

 

JSqlParser直接调用

PlainSelect jsqlDemo(String ta,String[][] condition,String[][] outColumn,String[][] groubyColumn,String[][] suboutColumn,String rowCount){

SimpleSelectDemo demo = new SimpleSelectDemo();

PlainSelect plainSelect = demo.jsqlDemo("a", "a", null, outColumn, groubyColumn, rowCount);

PlainSelect subplainSelect = demo.jsqlDemo(ta,null, condition, suboutColumn,null,null);

SubSelect subselect = new SubSelect();

subselect.setSelectBody(subplainSelect);

subselect.setAlias(new Alias("a",false));

plainSelect.setFromItem(subselect);

System.out.println("subselect:"+plainSelect);

return plainSelect;

}

}

 

连接查询:基于普通查询

条件设置

统计月份

12

客户类型

高值商客

直销客户编码

12

输出字段

统计月份

不使用函数

全部总用户数

不使用函数

 

目的SQL：

SELECT T_A.month, T_A.SUM_TOTAL  FROM KB_ZX_CUST_PROD_SUM T_A WHERE T_A.MONTH = '201512' AND  ( T_A.month = '12')  AND  ( T_A.VIP_TYPE = '高值商客')  AND  ( T_A.ZX_CUST_CODE = '12')  union all SELECT T_A.month, T_A.SUM_TOTAL  FROM KB_ZX_CUST_PROD_SUM T_A WHERE T_A.MONTH = '201512' AND  ( T_A.month = '12')  AND  ( T_A.VIP_TYPE = '高值商客')  AND  ( T_A.ZX_CUST_CODE = '12')

Demo:

package com.chinatmg.ecpp.helper;

 

import java.util.ArrayList;

import java.util.List;

 

import net.sf.jsqlparser.statement.select.PlainSelect;

import net.sf.jsqlparser.statement.select.SelectBody;

import net.sf.jsqlparser.statement.select.SetOperation;

import net.sf.jsqlparser.statement.select.SetOperationList;

import net.sf.jsqlparser.statement.select.UnionOp;

 

public class SimpleUnionSelect {

public static void main(String[] args){

String table= "KB_ZX_CUST_PROD_SUM";

String[][] condition ={{"MONTH","12"},{"VIP_TYPE","高值商客"},{"ZX_CUST_CODE","12"}};

String[][] outColumn = {{"MONTH"},{"SUM_TOTAL"}};

String limit = "122";

SimpleUnionSelect demo = new SimpleUnionSelect();

demo.selectDemo(table, null, condition, outColumn, null, limit);

demo.jsqlDemo(table, null, condition, outColumn, null, limit);

}

 

//SelectObject使用

SelectObject selectDemo(String table,String aliasName,String[][] condition,String[][] outColumn,String[][] groubyColumn,String limit){

SimpleSelectDemo demo = new SimpleSelectDemo();

SelectObject selectObject = demo.selectObjectDemo(table, aliasName, condition, outColumn, groubyColumn, limit);

selectObject.addUnionSelect(demo.selectObjectDemo(table, aliasName, condition, outColumn, groubyColumn, limit), false, true);

System.out.println("unionSelect:"+selectObject);

return selectObject;

}

 

//JSqlParser直接调用

SetOperationList jsqlDemo(String table,String aliasName,String[][] condition,String[][] outColumn,String[][] groubyColumn,String limit){

SimpleSelectDemo demo = new SimpleSelectDemo();

PlainSelect plainSelectA = demo.jsqlDemo(table, aliasName, condition, outColumn, groubyColumn, limit);

PlainSelect plainSelectB = demo.jsqlDemo(table, aliasName, condition, outColumn, groubyColumn, limit);

SetOperationList unionSelect = new SetOperationList();

List select = new ArrayList();

List brackets = new ArrayList();

List ops = new ArrayList();

//添加第一个Union语句

select.add(plainSelectA);

brackets.add(false);

 

//添加其他的Union语句

select.add(plainSelectB);

brackets.add(false);

UnionOp op = new UnionOp();

op.setAll(true);

ops.add(op);

 

unionSelect.setBracketsOpsAndSelects(brackets, select, ops);

System.out.println("unionSelect:"+unionSelect);

return unionSelect;

}

}

 

 

 

补充：

Join查询

条件设置

统计月份

12

客户类型

高值商客

直销客户编码

12

输出字段

统计月份

不使用函数

全部总用户数

不使用函数

Join条件

Id

Id

简单连接

目的SQL：

SELECT T_A.month, T_A.SUM_TOTAL  FROM KB_ZX_CUST_PROD_SUM T_A,KB_ZX_CUST_PROD_SUM T_B WHERE T_A.MONTH = '201512' AND  ( T_A.month = '12')  AND  ( T_A.VIP_TYPE = '高值商客')  AND  ( T_A.ZX_CUST_CODE = '12')

Demo:

package com.chinatmg.ecpp.helper;

 

import java.util.ArrayList;

import java.util.List;

 

import net.sf.jsqlparser.expression.Alias;

import net.sf.jsqlparser.schema.Table;

import net.sf.jsqlparser.statement.select.Join;

import net.sf.jsqlparser.statement.select.PlainSelect;

 

public class SimpleJoinSelect {

public static void main(String[] args){

SimpleJoinSelect demo = new SimpleJoinSelect();

String table= "KB_ZX_CUST_PROD_SUM";

String[][] condition ={{"MONTH","12"},{"VIP_TYPE","高值商客"},{"ZX_CUST_CODE","12"}};

String[][] outColumn = {{"MONTH"},{"SUM_TOTAL"}};

String limit = "122";

demo.selectObjectDemo(table, null,condition, outColumn,null,limit);

demo.jsqlDemo(table, null,condition, outColumn,null,limit);

}

 

//SelectObject使用

SelectObject selectObjectDemo(String table,String aliasName,String[][] condition,String[][] outColumn,String[][] groubyColumn,String limit){

SimpleSelectDemo demo = new SimpleSelectDemo();

SelectObject selectObject = demo.selectObjectDemo(table, aliasName, condition, outColumn, groubyColumn, limit);

selectObject.addJoin(table, "T_B", false).setSimple(true);

System.out.println("simple Join :"+selectObject);

return selectObject;

}

 

//JSqlParser直接调用

PlainSelect jsqlDemo(String ta,String aliasName,String[][] condition,String[][] outColumn,String[][] groubyColumn,String rowCount){

SimpleSelectDemo demo = new SimpleSelectDemo();

PlainSelect plainSelect = demo.jsqlDemo(ta, aliasName, condition, outColumn, groubyColumn, rowCount);

List joins = new ArrayList();

Join join = new Join();

Table table = new Table(ta);

table.setAlias(new Alias("T_B",false));

join.setRightItem(table);

join.setSimple(true);

joins.add(join);

plainSelect.setJoins(joins);

System.out.println("simple Join :"+plainSelect);

return plainSelect;

}

}

Join连接

目的SQL：

SELECT T_A.month, T_A.SUM_TOTAL  FROM KB_ZX_CUST_PROD_SUM T_A JOIN KB_ZX_CUST_PROD_SUM T_B ON T_A.ID = T_B.ID WHERE T_A.MONTH = '201512' AND  ( T_A.month = '12')  AND  ( T_A.VIP_TYPE = '高值商客')  AND  ( T_A.ZX_CUST_CODE = '12')

Demo:

package com.chinatmg.ecpp.helper;

 

import java.util.ArrayList;

import java.util.List;

 

import net.sf.jsqlparser.JSQLParserException;

import net.sf.jsqlparser.expression.Alias;

import net.sf.jsqlparser.expression.BinaryExpression;

import net.sf.jsqlparser.expression.operators.relational.EqualsTo;

import net.sf.jsqlparser.schema.Column;

import net.sf.jsqlparser.schema.Table;

import net.sf.jsqlparser.statement.select.Join;

import net.sf.jsqlparser.statement.select.PlainSelect;

 

 

public class SimpleJoinSelect {

public static void main(String[] args){

SimpleJoinSelect demo = new SimpleJoinSelect();

String table= "KB_ZX_CUST_PROD_SUM";

String[][] condition ={{"MONTH","12"},{"VIP_TYPE","高值商客"},{"ZX_CUST_CODE","12"}};

String[][] outColumn = {{"MONTH"},{"SUM_TOTAL"}};

String limit = "122";

demo.selectObjectDemo(table, null,condition, outColumn,null,limit);

demo.jsqlDemo(table, null,condition, outColumn,null,limit);

}

 

/*//SelectObject使用

SelectObject selectObjectDemo(String table,String aliasName,String[][] condition,String[][] outColumn,String[][] groubyColumn,String limit){

SimpleSelectDemo demo = new SimpleSelectDemo();

SelectObject selectObject = demo.selectObjectDemo(table, aliasName, condition, outColumn, groubyColumn, limit);

selectObject.addJoin(table, "T_B", false).setSimple(true);

System.out.println("simple Join :"+selectObject);

return selectObject;

}

 

//JSqlParser直接调用

PlainSelect jsqlDemo(String ta,String aliasName,String[][] condition,String[][] outColumn,String[][] groubyColumn,String rowCount){

SimpleSelectDemo demo = new SimpleSelectDemo();

PlainSelect plainSelect = demo.jsqlDemo(ta, aliasName, condition, outColumn, groubyColumn, rowCount);

List joins = new ArrayList();

Join join = new Join();

Table table = new Table(ta);

table.setAlias(new Alias("T_B",false));

join.setRightItem(table);

join.setSimple(true);

joins.add(join);

plainSelect.setJoins(joins);

System.out.println("simple Join :"+plainSelect);

return plainSelect;

}*/

 

//SelectObject使用

SelectObject selectObjectDemo(String table,String aliasName,String[][] condition,String[][] outColumn,String[][] groubyColumn,String limit){

SimpleSelectDemo demo = new SimpleSelectDemo();

SelectObject selectObject = demo.selectObjectDemo(table, aliasName, condition, outColumn, groubyColumn, limit);

Join join = selectObject.addJoin(table, "T_B", false);

//join.setSimple(false);

try {

SelectObject.addJoinOnExpression(join, "T_A.ID = T_B.ID");

} catch (JSQLParserException e) {

e.printStackTrace();

}

System.out.println("Join :"+selectObject);

return selectObject;

}

 

//JSqlParser直接调用

PlainSelect jsqlDemo(String ta,String aliasName,String[][] condition,String[][] outColumn,String[][] groubyColumn,String rowCount){

SimpleSelectDemo demo = new SimpleSelectDemo();

PlainSelect plainSelect = demo.jsqlDemo(ta, aliasName, condition, outColumn, groubyColumn, rowCount);

List joins = new ArrayList();

Join join = new Join();

Table table = new Table(ta);

table.setAlias(new Alias("T_B",false));

join.setRightItem(table);

//join.setSimple(true);

BinaryExpression onExpression = new EqualsTo();

onExpression.setLeftExpression(new Column(new Table("T_A"), "ID"));

onExpression.setRightExpression(new Column("T_B.ID"));

join.setOnExpression(onExpression);

joins.add(join);

plainSelect.setJoins(joins);

System.out.println("Join :"+plainSelect);

return plainSelect;

}

}

 

 

 

maven:


        com.github.jsqlparser
        jsqlparser
        0.9.7
    

 

package com.chinatmg.ecpp.helper;

import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

import net.sf.jsqlparser.JSQLParserException;
import net.sf.jsqlparser.expression.Alias;
import net.sf.jsqlparser.expression.Expression;
import net.sf.jsqlparser.expression.LongValue;
import net.sf.jsqlparser.expression.operators.conditional.AndExpression;
import net.sf.jsqlparser.expression.operators.conditional.OrExpression;
import net.sf.jsqlparser.parser.CCJSqlParserUtil;
import net.sf.jsqlparser.schema.Column;
import net.sf.jsqlparser.schema.Table;
import net.sf.jsqlparser.statement.select.FromItem;
import net.sf.jsqlparser.statement.select.Join;
import net.sf.jsqlparser.statement.select.Limit;
import net.sf.jsqlparser.statement.select.Offset;
import net.sf.jsqlparser.statement.select.OrderByElement;
import net.sf.jsqlparser.statement.select.OrderByElement.NullOrdering;
import net.sf.jsqlparser.statement.select.PlainSelect;
import net.sf.jsqlparser.statement.select.SelectBody;
import net.sf.jsqlparser.statement.select.SelectExpressionItem;
import net.sf.jsqlparser.statement.select.SelectItem;
import net.sf.jsqlparser.statement.select.SetOperation;
import net.sf.jsqlparser.statement.select.SetOperationList;
import net.sf.jsqlparser.statement.select.SubSelect;
import net.sf.jsqlparser.statement.select.UnionOp;

import org.apache.commons.lang.StringUtils;
public class SelectObject {
    private PlainSelect plainSelect;
    private Map mapJPTable;
    private SetOperationList unionSelect;
    
    public SelectObject() {
        super();
        setPlainSelect(new PlainSelect());
    }
    public SelectObject(PlainSelect plainSelect) {
        super();
        setPlainSelect(plainSelect);
    }
    
    /**
     * 生成表别名
     * @param key
     * @param tableName
     * @param aliasName
     * @param useAs 默认为true
     */
    public void generateTableAlias(String key,String tableName,String aliasName,boolean useAs){
        Table jpTable = new Table(tableName);
        jpTable.setAlias(new Alias(aliasName, useAs));
        if(mapJPTable==null){
            mapJPTable = new HashMap();
        }
        mapJPTable.put(key, jpTable);
    }
    
    /**
     * 生成表别名
     * @param key
     * @param tableName
     * @param aliasName useAs 默认为true
     */
    public void generateTableAlias(String key,String tableName,String aliasName){
        generateTableAlias(key, tableName, aliasName, true);
    }
    
    /**
     * 根据key获取Table
     * @param key
     * @return Table
     */
    public Table getTableByKey(String key){
        if(mapJPTable==null){
            return null;
        }
        return mapJPTable.get(key);
    }
    
    /**
     * 根据key获取别名
     * @param key
     * @return String
     */
    public String getTableAlias(String key){
        Table table = getTableByKey(key);
        if(table!=null&&table.getAlias()!=null){
            return table.getAlias().getName();
        }
        return null;
    }
    
    /**
     * 添加查询体
     * @param table
     * @param columnName
     * @param aliasName useAs 默认为true
     */
    public void addSelectItem(Table table,String columnName,String aliasName){
        addSelectItem(table, columnName, aliasName, true);
    }
    
    /**
     * 添加查询体
     * @param table
     * @param columnName
     * @param aliasName
     * @param useAs 默认为true
     */
    public void addSelectItem(Table table,String columnName,String aliasName,boolean useAs){
        SelectExpressionItem selectItem = new SelectExpressionItem();
        selectItem.setExpression(new Column(table,columnName));
        if(StringUtils.isNotEmpty(aliasName)){
            selectItem.setAlias(new Alias(aliasName,useAs));
        }
        addSelectItem(selectItem);
    }
    
    /**
     * 添加查询体
     * @param selectItem
     */
    public void addSelectItem(SelectItem selectItem){
        if(plainSelect.getSelectItems()==null){
            plainSelect.addSelectItems(selectItem);
            return;
        }
        if(!contains(plainSelect.getSelectItems(),selectItem)){
            plainSelect.addSelectItems(selectItem);
        }
    }
    
    /**
     * 添加查询体 该方法不会生成别名
     * @param selectString
     */
    public  void addSelectItem(String selectString){
        SelectExpressionItem selectItem = new SelectExpressionItem();
        try {
            selectItem.setExpression(CCJSqlParserUtil.parseCondExpression(selectString));
            addSelectItem(selectItem);
        } catch (JSQLParserException e) {
            e.printStackTrace();
        }
    }
    
    /**
     * 添加查询体 
     * @param selectString
     * @param aliasName
     * @param  useAs 默认为true
     */
    public  void addSelectItem(String selectString,String aliasName,boolean useAs){
        SelectExpressionItem selectItem = new SelectExpressionItem();
        try {
            selectItem.setExpression(CCJSqlParserUtil.parseCondExpression(selectString));
            if(StringUtils.isNotEmpty(aliasName)){
                selectItem.setAlias(new Alias(aliasName,useAs));
            }
            addSelectItem(selectItem);
        } catch (JSQLParserException e) {
            e.printStackTrace();
        }
    }
    
    /**
     * 添加查询体 
     * @param selectString useAs 默认为true
     */
    public  void addSelectItem(String selectString,String aliasName){
        addSelectItem(selectString, aliasName, true);
    }
    /**
     * 设置查询表
     * @param item
     */
    public void setFromItem(FromItem item) {
        plainSelect.setFromItem(item);
    }
    /**
     * 添加join左外连接
     * @param table
     * @return
     */
    public Join addJoinLO(FromItem rightItem){
        return addJoin(rightItem, true, false, true, false);
    }
    
    /**
     * 添加join左内连接
     * @param table
     * @return
     */
    public Join addJoinLI(FromItem rightItem){
        return addJoin(rightItem, true, true, false, false);
    }
    
    /**
     * 添加join连接
     * @param table
     * @return
     */
    public Join addJoin(FromItem rightItem){
        return addJoin(rightItem, false, false, false, false);
    }
    
    /**
     * 添加join连接
     * @param join
     * @return Join
     */
    public Join addJoin(Join join){
        return addJoin(join, false, false, false, false);
    }
    
    /**
     * 添加join连接
     * @param tableName
     * @return
     */
    public Join addJoin(String tableName){
        return addJoin(tableName, null,false);
    }
    
    /**
     * 添加join连接
     * @param tableName
     * @param aliasName
     * @param useAs
     * @return
     */
    public Join addJoin(String tableName,String aliasName,boolean useAs){
        Table table = new Table(tableName);
        if(StringUtils.isNotEmpty(aliasName)){
            table.setAlias(new Alias(aliasName, useAs));
        }
        return addJoin(table, false, false, false, false);
    }
    
    /**
     * 添加join连接
     * @param rightItem
     * @param left
     * @param inner
     * @param outter
     * @param right
     * @return Join
     */
    public Join addJoin(FromItem rightItem,boolean left,boolean inner,boolean outter,boolean right){
        Join join = new Join();
        join.setRightItem(rightItem);
        return addJoin(join, left, inner, outter, right);
    }
    
    /**
     * 添加join连接
     * @param join
     * @param left
     * @param inner
     * @param outter
     * @param right
     * @return
     */
    public Join addJoin(Join join,boolean left,boolean inner,boolean outter,boolean right){
        if(left){
            join.setLeft(left);
        }else if(right){
            join.setRight(right);
        }
        if(inner){
            join.setInner(inner);
        }else if(outter){
            join.setOuter(outter);
        }
        if(!contains(getListJoin(),join)){
            getListJoin().add(join);
        }
        return join;
    }
    /**
     * 添加join连接条件
     * @param join
     * @param onExpression
     * @param isOr
     */
    public static void addJoinOnExpression(Join join,Expression onExpression,boolean isOr){
        if(join==null){
            return;
        }
        if(join.getOnExpression() ==null){
            join.setOnExpression(onExpression);
            return;
        }
        if(isOr){
            join.setOnExpression(new OrExpression(join.getOnExpression(), onExpression));
        }else{
            join.setOnExpression(new AndExpression(join.getOnExpression(),onExpression));
        }
    }
    
    /**
     * 添加join连接条件
     * @param join
     * @param onExpression 默认为 and连接
     */
    public static void addJoinOnExpression(Join join,Expression onExpression){
        addJoinOnExpression(join,onExpression, false);
    }
    
    /**
     * 添加join连接条件
     * @param join
     * @param onExpression
     * @throws JSQLParserException 默认为 and连接
     */
    public static void addJoinOnExpression(Join join,String onExpression) throws JSQLParserException{
        addJoinOnExpression(join,CCJSqlParserUtil.parseCondExpression(onExpression));    
    }
    
    /**
     * 添加join连接条件
     * @param join
     * @param onExpression
     * @param isOr
     * @throws JSQLParserException
     */
    public static void addJoinOnExpression(Join join,String onExpression,boolean isOr) throws JSQLParserException{
        addJoinOnExpression(join,CCJSqlParserUtil.parseCondExpression(onExpression),isOr);    
    }
    
    /**
     * 添加where条件
     * @param whereExpression
     * @param isOr
     */
    public void addWhereExpression(Expression whereExpression,boolean isOr){
        if(plainSelect.getWhere() ==null){
            plainSelect.setWhere(whereExpression);
            return;
        }
        if(isOr){
            plainSelect.setWhere(new OrExpression(plainSelect.getWhere(), whereExpression));
        }else{
            plainSelect.setWhere(new AndExpression(plainSelect.getWhere(),whereExpression));
        }
    }
    
    /**
     * 添加where条件
     * @param whereExpression 默认为 and连接
     */
    public void addWhereExpression(Expression whereExpression){
        addWhereExpression(whereExpression, false);
    }
    
    /**
     * 添加where条件
     * @param whereExpression
     * @throws JSQLParserException 默认为 and连接
     */
    public void addWhereExpression(String whereExpression) throws JSQLParserException{
        addWhereExpression(CCJSqlParserUtil.parseCondExpression(whereExpression));    
    }
    
    /**
     * 添加where条件
     * @param whereExpression
     * @param isOr
     * @throws JSQLParserException
     */
    public void addWhereExpression(String whereExpression,boolean isOr) throws JSQLParserException{
        addWhereExpression(CCJSqlParserUtil.parseCondExpression(whereExpression),isOr);    
    }
    
    /**
     * 添加groupBy语句
     * @param groupByString
     */
    public  void addGroupByExpression(String groupByString){
        try {
            Expression groupByExpression = CCJSqlParserUtil.parseCondExpression(groupByString);
            addGroupByExpression(groupByExpression);
        } catch (JSQLParserException e) {
            e.printStackTrace();
        }
    }
    
    /**
     * 添加groupBy语句
     * @param groupByExpression
     */
    public  void addGroupByExpression(Expression groupByExpression){
        List listGroupByExpression =plainSelect.getGroupByColumnReferences();
        if(listGroupByExpression==null){
            plainSelect.addGroupByColumnReference(groupByExpression);
            return;
        }
        if(!contains(listGroupByExpression,groupByExpression)){
            //如果为空说明有问题
            plainSelect.addGroupByColumnReference(groupByExpression);
        }
    }
    
    /**
     * 添加having语句
     * @param havingExpression
     * @param isOr
     */
    public void addHavingExpression(Expression havingExpression,boolean isOr){
        if(plainSelect.getHaving() ==null){
            plainSelect.setHaving(havingExpression);
            return;
        }
        if(isOr){
            plainSelect.setHaving(new OrExpression(plainSelect.getHaving(), havingExpression));
        }else{
            plainSelect.setHaving(new AndExpression(plainSelect.getHaving(),havingExpression));
        }
    }
    
    /**
     * 添加having语句
     * @param havingExpression
     */
    public void addHavingExpression(Expression havingExpression){
        addWhereExpression(havingExpression, false);
    }
    
    /**
     * 添加having语句
     * @param havingExpression
     * @throws JSQLParserException
     */
    public void addHavingExpression(String havingExpression) throws JSQLParserException{
        addWhereExpression(CCJSqlParserUtil.parseCondExpression(havingExpression));    
    }
    
    /**
     * 添加having语句
     * @param havingExpression
     * @param isOr
     * @throws JSQLParserException
     */
    public void addHavingExpression(String havingExpression,boolean isOr) throws JSQLParserException{
        addWhereExpression(CCJSqlParserUtil.parseCondExpression(havingExpression),isOr);    
    }
    
    
    /**
     * 添加orderBy语句
     * @param orderByElement
     * @return
     */
    public boolean addOrderByExpression(OrderByElement orderByElement){
        boolean result=false;
        if(!contains(getOrderByElements(),orderByElement)){
            //如果为空说明有问题
            result |=getOrderByElements().add(orderByElement);
        }
        return result;
    }
    
    /**
     * 添加orderBy语句
     * @param orderByExpression
     * @param isDesc
     * @param isNullsFirst
     * @return
     */
    public boolean addOrderByExpression(Expression orderByExpression,boolean isDesc,boolean isNullsFirst){
        OrderByElement orderByElement = new OrderByElement();
        orderByElement.setExpression(orderByExpression);
        if(isDesc){
            orderByElement.setAsc(!isDesc);
        }else{
            orderByElement.setAscDescPresent(!isDesc);
        }
        if(isNullsFirst){
            orderByElement.setNullOrdering(NullOrdering.NULLS_FIRST);
        }else{
            orderByElement.setNullOrdering(NullOrdering.NULLS_LAST);
        }
        return addOrderByExpression(orderByElement);
    }
    /**
     * 添加orderBy语句
     * @param orderByExpression
     * @param isDesc
     * @return
     */
    public boolean addOrderByExpression(Expression orderByExpression,boolean isDesc){
        OrderByElement orderByElement = new OrderByElement();
        orderByElement.setExpression(orderByExpression);
        if(isDesc){
            orderByElement.setAsc(!isDesc);
        }else{
            orderByElement.setAscDescPresent(!isDesc);
        }
        return addOrderByExpression(orderByElement);
    }
    
    /**
     * 添加orderBy语句
     * @param orderByExpression
     * @return
     */
    public boolean addOrderByExpression(Expression orderByExpression){
        return addOrderByExpression(orderByExpression,false);
    }
    
    /**
     * 添加orderBy语句
     * @param orderByExpression
     * @param isDesc
     * @param isNullsFirst
     * @return
     * @throws JSQLParserException
     */
    public boolean addOrderByExpression(String orderByExpression,boolean isDesc,boolean isNullsFirst) throws JSQLParserException{
        return addOrderByExpression(CCJSqlParserUtil.parseCondExpression(orderByExpression), isDesc, isNullsFirst);
    }
    
    /**
     * 添加orderBy语句
     * @param orderByExpression
     * @param isDesc
     * @return
     * @throws JSQLParserException
     */
    public boolean addOrderByExpression(String orderByExpression,boolean isDesc) throws JSQLParserException{
        return addOrderByExpression(CCJSqlParserUtil.parseCondExpression(orderByExpression),isDesc);
    }
    
    /**
     * 添加orderBy语句
     * @param orderByExpression
     * @return
     * @throws JSQLParserException
     */
    public boolean addOrderByExpression(String orderByExpression) throws JSQLParserException{
        return addOrderByExpression(orderByExpression,false);
    }
    
    private void setSubselectBody(SelectBody selectBody,String aliasName,boolean userAs){
        SubSelect subSelect =new SubSelect();
        subSelect.setSelectBody(selectBody);
        if(StringUtils.isNotEmpty(aliasName)){
            subSelect.setAlias(new Alias(aliasName,userAs));
        }
        setFromItem(subSelect);
    }
    /**
     * 添加子查询
     * @param selectObject
     * @param aliasName
     * @param userAs
     */
    public void setSubselectObject(SelectObject selectObject,String aliasName,boolean userAs){
        if(selectObject!=null){
            setSubselectBody(selectObject.getSelectBody(),aliasName,userAs);
        }
    }
    
    /**
     * 添加子查询
     * @param selectObject
     */
    public void setSubselectObject(SelectObject selectObject){
        setSubselectObject(selectObject, null, false);
    }
    
    /**
     * 设置Limit
     * @param rowCount
     */
    public void setLimit(String rowCount){
        Limit limit = new Limit();
        limit.setRowCount(new LongValue(rowCount));
        plainSelect.setLimit(limit);
    }
    
    /**
     * 获取Limit
     * @param rowCount
     */
    public Limit getLimit(){
        return plainSelect.getLimit();
    }
    
    /**
     * 设置Offset
     * @param start
     */
    public void setOffset(long start){
        Offset offset = new Offset();
        offset.setOffset(start);
        plainSelect.setOffset(offset);
    }
    
    /**
     * 获取Offset
     * @param start
     */
    public Offset getOffset(){
        return plainSelect.getOffset();
    }
    
    /**
     * 添加unionSelect
     * @param selectObject
     * @param isBracket 默认为false
     * @param isUnionAll 默认为false
     */
    public void addUnionSelect(SelectObject selectObject,boolean isBracket,boolean isUnionAll){
        if(selectObject!=null){
            addUnionSelectBody(selectObject.getSelectBody(), isBracket, isUnionAll);
        }
    }
    
    /**
     * 添加unionSelect
     * @param selectObject
     * @param isBracket isUnionAll 默认为false
     */
    public void addUnionSelect(SelectObject selectObject,boolean isBracket){
        addUnionSelect(selectObject, isBracket, false);
    }
    
    /**
     * 添加unionSelect
     * @param selectObject 
     */
    public void addUnionSelect(SelectObject selectObject){
        addUnionSelect(selectObject, false, false);
    }
    
    /**
     * 添加unionSelect
     * @param plainSelect
     * @param isBracket
     * @param isUnionAll
     */
    public void addUnionSelect(PlainSelect plainSelect,boolean isBracket,boolean isUnionAll){
        if(plainSelect!=null){
            addUnionSelectBody(plainSelect, isBracket, isUnionAll);
        }
    }
    
    /**
     * 添加unionSelect
     * @param plainSelect
     * @param isBracket
     */
    public void addUnionSelect(PlainSelect plainSelect,boolean isBracket){
        addUnionSelect(plainSelect, isBracket, false);
    }
    
    /**
     * 添加unionSelect
     * @param plainSelect
     */
    public void addUnionSelect(PlainSelect plainSelect){
        addUnionSelect(plainSelect, false, false);
    }
    
    private void addUnionSelectBody(SelectBody selectBody,boolean isBracket,boolean isUnionAll){
        if(selectBody!=null){
            if(unionSelect==null){
                unionSelect = new SetOperationList();
            }
            List selects = unionSelect.getSelects();
            List brackets = unionSelect.getBrackets();
            if(selects==null){
                selects = new ArrayList();
            }
            if(brackets==null){
                brackets = new ArrayList();
            }
            List operations = unionSelect.getOperations();
            if(operations==null){
                operations = new ArrayList();
            }
            //本身作为第一条语句
            if(selects.size()==0){
                selects.add(getSelectBody());
                brackets.add(false);
            }
            
            selects.add(selectBody);
            brackets.add(isBracket);
            UnionOp operation=new UnionOp();
            if(isUnionAll){
                operation.setAll(isUnionAll);
            }
            operations.add(operation);
            unionSelect.setBracketsOpsAndSelects(brackets, selects, operations);
        }
    }
    
    
    
    /**
     * 添加orderBy语句
     * @param orderByElement
     * @return
     */
    public boolean addUnionOrderByExpression(OrderByElement orderByElement){
        boolean result=false;
        if(!contains(getUnionOrderByElements(),orderByElement)){
            //如果为空说明有问题
            result |=getUnionOrderByElements().add(orderByElement);
        }
        return result;
    }
    
    /**
     * 添加orderBy语句
     * @param orderByExpression
     * @param isDesc
     * @param isNullsFirst
     * @return
     */
    public boolean addUnionOrderByExpression(Expression orderByExpression,boolean isDesc,boolean isNullsFirst){
        OrderByElement orderByElement = new OrderByElement();
        orderByElement.setExpression(orderByExpression);
        if(isDesc){
            orderByElement.setAsc(!isDesc);
        }else{
            orderByElement.setAscDescPresent(!isDesc);
        }
        if(isNullsFirst){
            orderByElement.setNullOrdering(NullOrdering.NULLS_FIRST);
        }else{
            orderByElement.setNullOrdering(NullOrdering.NULLS_LAST);
        }
        return addUnionOrderByExpression(orderByElement);
    }
    /**
     * 添加orderBy语句
     * @param orderByExpression
     * @param isDesc
     * @return
     */
    public boolean addUnionOrderByExpression(Expression orderByExpression,boolean isDesc){
        OrderByElement orderByElement = new OrderByElement();
        orderByElement.setExpression(orderByExpression);
        if(isDesc){
            orderByElement.setAsc(!isDesc);
        }else{
            orderByElement.setAscDescPresent(!isDesc);
        }
        return addUnionOrderByExpression(orderByElement);
    }
    
    /**
     * 添加orderBy语句
     * @param orderByExpression
     * @return
     */
    public boolean addUnionOrderByExpression(Expression orderByExpression){
        return addUnionOrderByExpression(orderByExpression,false);
    }
    
    /**
     * 添加orderBy语句
     * @param orderByExpression
     * @param isDesc
     * @param isNullsFirst
     * @return
     * @throws JSQLParserException
     */
    public boolean addUnionOrderByExpression(String orderByExpression,boolean isDesc,boolean isNullsFirst) throws JSQLParserException{
        return addUnionOrderByExpression(CCJSqlParserUtil.parseCondExpression(orderByExpression), isDesc, isNullsFirst);
    }
    
    /**
     * 添加orderBy语句
     * @param orderByExpression
     * @param isDesc
     * @return
     * @throws JSQLParserException
     */
    public boolean addUnionOrderByExpression(String orderByExpression,boolean isDesc) throws JSQLParserException{
        return addUnionOrderByExpression(CCJSqlParserUtil.parseCondExpression(orderByExpression),isDesc);
    }
    
    /**
     * 添加orderBy语句
     * @param orderByExpression
     * @return
     * @throws JSQLParserException
     */
    public boolean addUnionOrderByExpression(String orderByExpression) throws JSQLParserException{
        return addUnionOrderByExpression(orderByExpression,false);
    }
    
    
    
    /**
     * 设置unionLimit
     * @param rowCount
     */
    public void setUnionLimit(String rowCount){
        Limit limit = new Limit();
        limit.setRowCount(new LongValue(rowCount));
        unionSelect.setLimit(limit);
    }
    
    /**
     * 获取unionLimit
     * @param rowCount
     */
    public Limit getUnionLimit(){
        return unionSelect.getLimit();
    }
    
    /**
     * 设置unionOffset
     * @param start
     */
    public void setUnionOffset(long start){
        Offset offset = new Offset();
        offset.setOffset(start);
        unionSelect.setOffset(offset);
    }
    
    /**
     * 获取unionOffset
     * @param start
     */
    public Offset getUnionOffset(){
        return unionSelect.getOffset();
    }
    
    public PlainSelect getPlainSelect() {
        return plainSelect;
    }
    public void setPlainSelect(PlainSelect plainSelect) {
        if(plainSelect==null){
            plainSelect =new PlainSelect();
        }
        this.plainSelect = plainSelect;
    }
    public Map getMapJPTable() {
        if(mapJPTable==null){
            mapJPTable =new HashMap();
        }
        return mapJPTable;
    }
    public void setMapJPTable(Map mapJPTable) {
        this.mapJPTable = mapJPTable;
    }
    public List getListJoin() {
        if(plainSelect.getJoins()==null){
            plainSelect.setJoins(new ArrayList());
        }
        return plainSelect.getJoins();
    }
    public void setListJoin(List listJoin) {
        plainSelect.setJoins(listJoin);
    }
    public List getOrderByElements() {
        if(plainSelect.getOrderByElements()==null){
            plainSelect.setOrderByElements(new ArrayList());
        }
        return plainSelect.getOrderByElements();
    }
    public void setOrderByElements(List orderByElements) {
        plainSelect.setOrderByElements(orderByElements);
    }
    public SetOperationList getUnionSelect() {
        return unionSelect;
    }
    public void setUnionSelect(SetOperationList unionSelect) {
        this.unionSelect = unionSelect;
    }
    
    public List getUnionOrderByElements() {
        if(unionSelect.getOrderByElements()==null){
            unionSelect.setOrderByElements(new ArrayList());
        }
        return unionSelect.getOrderByElements();
    }
    @Override
    public String toString() {
        return plainSelect==null?"":getSelectBody().toString();
    }
    
    public SelectBody getSelectBody(){
        getPlainSelect();

        /*if(plainSelect.getSelectItems()==null){
            SelectExpressionItem selectItem = new SelectExpressionItem();
            selectItem.setExpression(new LongValue("*"));
            addSelectItem(selectItem);
        }*/
        if(unionSelect!=null&&unionSelect.getSelects()!=null){
            return unionSelect;
        }
        /*if(plainSelect.getFromItem()!=null){
            setSubselectBody(unionSelect, null, false);
        }*/
        return plainSelect;
    }
    public static boolean contains(List list,Object object){
        if(list==null||list.size()==0){
            return false;
        }
        for(Object obj:list){
            if(obj==null) continue;
            if(object.toString().trim().equalsIgnoreCase(obj.toString().trim())){
                return true;
            }
        }
        return false;
    }
}

 

转载于:https://my.oschina.net/youfen/blog/1936319

你可能感兴趣的:(JSqlParser基本应用文档-select部分)

  • 【iOS】MVC设计模式 Magnetic_h iosmvc设计模式objective-c学习ui
    MVC前言如何设计一个程序的结构，这是一门专门的学问，叫做"架构模式"（architecturalpattern），属于编程的方法论。MVC模式就是架构模式的一种。它是Apple官方推荐的App开发架构，也是一般开发者最先遇到、最经典的架构。MVC各层controller层Controller/ViewController/VC（控制器）负责协调Model和View，处理大部分逻辑它将数据从Mod
  • element实现动态路由+面包屑 软件技术NINI vue案例vue.js前端
    el-breadcrumb是ElementUI组件库中的一个面包屑导航组件，它用于显示当前页面的路径，帮助用户快速理解和导航到应用的各个部分。在Vue.js项目中，如果你已经安装了ElementUI，就可以很方便地使用el-breadcrumb组件。以下是一个基本的使用示例：安装ElementUI（如果你还没有安装的话）:你可以通过npm或yarn来安装ElementUI。bash复制代码npmi
  • 《投行人生》读书笔记 小蘑菇的树洞
    《投行人生》----作者詹姆斯-A-朗德摩根斯坦利副主席40年的职业洞见-很短小精悍的篇幅，比较适合初入职场的新人。第一部分成功的职业生涯需要规划1.情商归为适应能力分享与协作同理心适应能力，更多的是自我意识，你有能力识别自己的情并分辨这些情绪如何影响你的思想和行为。2.对于初入职场的人的建议，细节，截止日期和数据很重要截止日期，一种有效的方法是请老板为你所有的任务进行优先级排序。和老板喝咖啡的好
  • 扫地机类清洁产品之直流无刷电机控制 悟空胆好小 清洁服务机器人单片机人工智能
    扫地机类清洁产品之直流无刷电机控制1.1前言扫地机产品有很多的电机控制，滚刷电机1个，边刷电机1-2个，清水泵电机，风机一个，部分中高端产品支持抹布功能，也就是存在抹布盘电机，还有追觅科沃斯石头等边刷抬升电机，滚刷抬升电机等的，这些电机有直流有刷电机，直接无刷电机，步进电机，电磁阀，挪动泵等不同类型。电机的原理，驱动控制方式也不行。接下来一段时间的几个文章会作个专题分析分享。直流有刷电机会自动持续
  • 消息中间件有哪些常见类型 xmh-sxh-1314 java
    消息中间件根据其设计理念和用途，可以大致分为以下几种常见类型：点对点消息队列（Point-to-PointMessagingQueues）：在这种模型中，消息被发送到特定的队列中，消费者从队列中取出并处理消息。队列中的消息只能被一个消费者消费，消费后即被删除。常见的实现包括IBM的MQSeries、RabbitMQ的部分使用场景等。适用于任务分发、负载均衡等场景。发布/订阅消息模型（Pub/Sub
  • html 中如何使用 uniapp 的部分方法 某公司摸鱼前端 htmluni-app前端
    示例代码：Documentconsole.log(window);效果展示：好了，现在就可以uni.使用相关的方法了
  • 【一起学Rust | 设计模式】习惯语法——使用借用类型作为参数、格式化拼接字符串、构造函数 广龙宇 一起学Rust#Rust设计模式rust设计模式开发语言
    提示：文章写完后，目录可以自动生成，如何生成可参考右边的帮助文档文章目录前言一、使用借用类型作为参数二、格式化拼接字符串三、使用构造函数总结前言Rust不是传统的面向对象编程语言，它的所有特性，使其独一无二。因此，学习特定于Rust的设计模式是必要的。本系列文章为作者学习《Rust设计模式》的学习笔记以及自己的见解。因此，本系列文章的结构也与此书的结构相同（后续可能会调成结构），基本上分为三个部分
  • Python教程：一文了解使用Python处理XPath 旦莫 Python进阶python开发语言
    目录1.环境准备1.1安装lxml1.2验证安装2.XPath基础2.1什么是XPath？2.2XPath语法2.3示例XML文档3.使用lxml解析XML3.1解析XML文档3.2查看解析结果4.XPath查询4.1基本路径查询4.2使用属性查询4.3查询多个节点5.XPath的高级用法5.1使用逻辑运算符5.2使用函数6.实战案例6.1从网页抓取数据6.1.1安装Requests库6.1.2代
  • 关于提高复杂业务逻辑代码可读性的思考 编程经验分享 开发经验java数据库开发语言
    目录前言需求场景常规写法拆分方法领域对象总结前言实际工作中大部分时间都是在写业务逻辑，一般都是三层架构，表示层（Controller）接收客户端请求，并对入参做检验，业务逻辑层（Service）负责处理业务逻辑，一般开发都是在这一层中写具体的业务逻辑。数据访问层（Dao）是直接和数据库交互的，用于查数据给业务逻辑层，或者是将业务逻辑层处理后的数据写入数据库。简单的增删改查接口不用多说，基本上写好一
  • 【夜读】提升生活品质的8个建议 茳淮秀水
    停止攀比很多人之所以感觉疲惫，部分原因是来自于跟别人攀比。殊不知，攀比得到的满足只是片刻的，过后往往会感到空虚。过分在意别人的评价，丢失的是自己原有的审美，扰乱的是自己最初的节奏。不妨活得洒脱些，自己内心丰盈了，快乐就能更持久。停止自责想改变自己，先从接纳自己开始。越是过分自责，就越难改变现状，因为如果把精力全耗在自责上，就没有精力用来改变了。遇到问题，我们要用正确的心态去面对。与其一味自责，不如
  • SQL Server_查询某一数据库中的所有表的内容 qq_42772833 SQLServer数据库sqlserver
    1.查看所有表的表名要列出CrabFarmDB数据库中的所有表（名），可以使用以下SQL语句：USECrabFarmDB;--切换到目标数据库GOSELECTTABLE_NAMEFROMINFORMATION_SCHEMA.TABLESWHERETABLE_TYPE='BASETABLE';对这段SQL脚本的解释：SELECTTABLE_NAME：这个语句的作用是从查询结果中选择TABLE_NAM
  • 如何部分格式化提示模板:LangChain中的高级技巧 nseejrukjhad langchainjava服务器python
    标题:如何部分格式化提示模板:LangChain中的高级技巧内容:如何部分格式化提示模板:LangChain中的高级技巧引言在使用大型语言模型(LLM)时,提示工程是一个关键环节。LangChain提供了强大的提示模板功能,让我们能更灵活地构建和管理提示。本文将介绍LangChain中一个高级特性-部分格式化提示模板,这个技巧可以让你的提示管理更加高效和灵活。什么是部分格式化提示模板?部分格式化提
  • 没有一件绝对好看的衣服 段童
    没有一件绝对好看的衣服只有好看的人没有绝对好看的人只有你可能会爱上的他没有你绝对会爱上的他只有你从来就缺少的那一部分的自己爱是本能的脆弱是欲望的茧——《没有一件绝对好看的衣服》
  • 把握“三度”打造“三有”干部队伍 辛德瑞拉卡卡卡
    “胜败兴亡之分，不得不归咎于人事也”。干部队伍建设工作的好坏，关系到党和国家的发展全局。近日，新疆维吾尔自治区党委书记马兴瑞在部分党群单位走访调研时强调，要努力培养造就忠诚干净担当的高素质专业化干部队伍。各级组织部门应当在培养选拔干部、吸收优秀青年到党内来、培养造就优秀人才上下功夫，切实增强干部投身实践、解决问题、推进工作的能力，着力打造高素质专业化干部队伍。“天生我材必有用”，增强选育有“准度”
  • Day1笔记-Python简介&标识符和关键字&输入输出 ~在杰难逃~ Pythonpython开发语言大数据数据分析数据挖掘
    大家好，从今天开始呢，杰哥开展一个新的专栏，当然，数据分析部分也会不定时更新的，这个新的专栏主要是讲解一些Python的基础语法和知识，帮助0基础的小伙伴入门和学习Python，感兴趣的小伙伴可以开始认真学习啦！一、Python简介【了解】1.计算机工作原理编程语言就是用来定义计算机程序的形式语言。我们通过编程语言来编写程序代码，再通过语言处理程序执行向计算机发送指令，让计算机完成对应的工作，编程
  • 人工智能时代，程序员如何保持核心竞争力？ jmoych 人工智能
    随着AIGC（如chatgpt、midjourney、claude等）大语言模型接二连三的涌现，AI辅助编程工具日益普及，程序员的工作方式正在发生深刻变革。有人担心AI可能取代部分编程工作，也有人认为AI是提高效率的得力助手。面对这一趋势,程序员应该如何应对?是专注于某个领域深耕细作，还是广泛学习以适应快速变化的技术环境?又或者，我们是否应该将重点转向AI无法轻易替代的软技能？让我们一起探讨程序员
  • Python爬虫解析工具之xpath使用详解 eqa11 python爬虫开发语言
    文章目录Python爬虫解析工具之xpath使用详解一、引言二、环境准备1、插件安装2、依赖库安装三、xpath语法详解1、路径表达式2、通配符3、谓语4、常用函数四、xpath在Python代码中的使用1、文档树的创建2、使用xpath表达式3、获取元素内容和属性五、总结Python爬虫解析工具之xpath使用详解一、引言在Python爬虫开发中，数据提取是一个至关重要的环节。xpath作为一门
  • ARM驱动学习之基础小知识 JT灬新一 ARM嵌入式arm开发学习
    ARM驱动学习之基础小知识•sch原理图工程师工作内容–方案–元器件选型–采购（能不能买到，价格）–原理图（涉及到稳定性）•layout画板工程师–layout（封装、布局，布线，log）（涉及到稳定性）–焊接的一部分工作（调试阶段板子的焊接）•驱动工程师–驱动，原理图，layout三部分的交集容易发生矛盾•PCB研发流程介绍–方案，原理图(网表)–layout工程师（gerber文件）–PCB板
  • 【PG】常见数据库、表属性设置 江无羡 数据库
    PG的常见属性配置方法数据库复制、备份相关表的复制标识单表操作批量表操作链接数据库复制、备份相关表的复制标识单表操作通过ALTER语句单独更改一张表的复制标识。ALTERTABLE[tablename]REPLICAIDENTITYFULL;批量表操作通过代码块的方式，对某个schema中的所有表一起更新其复制标识。SELECTtablename,CASErelreplidentWHEN'd'TH
  • docker igotyback eureka云原生
    Docker容器的文件系统是隔离的，但是可以通过挂载卷（Volumes）或绑定挂载（BindMounts）将宿主机的文件系统目录映射到容器内部。要查看Docker容器的映射路径，可以使用以下方法：查看容器配置：使用dockerinspect命令可以查看容器的详细配置信息，包括挂载的卷。例如：bashdockerinspect在输出的JSON格式中，查找"Mounts"部分，这里会列出所有的挂载信息
  • 18、架构-可观测性之聚合度量 大树~~ 架构javapython后端架构
    聚合度量聚合度量是指对系统运行时产生的各种指标数据进行收集、聚合和分析，以了解系统的健康状况和性能表现。聚合度量是可观测性的关键组成部分，通过对度量数据的分析，可以及时发现系统中的异常和瓶颈。以下是对聚合度量各个方面的详细解析，并结合具体的数据案例和技术支撑。指标收集收集系统运行时产生的各种指标数据是聚合度量的基础。常见的指标包括CPU使用率、内存使用率、请求处理时间、请求数、错误率等。以下是指标
  • 教育 用心灵温暖心灵
    @陈春丽长期学习班冯倩。今天一早就听到说高职合并，取消中专教育的教育信息。感觉是虽然知道，再听还是吓一跳。国家重视职业教育为何还要取消中专技术学校的教育？再听高中就要进行技术教育了，一部分人学习好继续努力学习考大学，一部分人在高中就可以进行职业教育接受职业教育了还要中专技术教育学校干什么呢！a有些职业教育学校转型升级快，不是孩子上完给找工作，而是学校帮孩子创业，我觉得是不错的方向！新闻新你得实时更
  • 读《人间鲁迅》有感 琳语读书
    上周读完《闻一多传》后，我对中国近代知识分子产生了兴趣，这周继续读了《人间鲁迅》。厚厚的两本书，记录了一个人的一生，苦痛，彷徨和挣扎，虽然只读了一小部分，却也心潮澎湃。闻一多和鲁迅是完全不同的。鲁迅是沉郁的，现实的，寂寞的，抗争的。除了天生性格的不同外，环境的塑造也是非常之大。鲁迅少年经历了家庭的变故，看尽了人间冷暖，世态炎凉。这种经历促使他很早就观察思考人生，立志用文学来改变中国国民的劣根。闻一
  • 在Ubuntu中编译含有JSON的文件出现报错 芝麻糊76 Linuxkill_buglinuxubuntujson
    在ubuntu中进行JSON相关学习的时候，我发现了一些小问题，决定与大家进行分享，减少踩坑时候出现不必要的时间耗费截取部分含有JSON部分的代码进行展示char*str="{\"title\":\"JSONExample\",\"author\":{\"name\":\"JohnDoe\",\"age\":35,\"isVerified\":true},\"tags\":[\"json\",\"
  • 2023-07-24 DXZHY
    很2023年7月24号星期天，今天呢一早我就去开店，淋完花我就赶去了中心联谊，感谢中心联谊过程当中，他们在唱诵读者上面1.一边流泪，感觉自己的内在灵魂太长，时间没有得到这样了，所以一边唱手一边在流泪，我分不清楚自己是感动了，还是被呼唤的灵魂所能看到，但我就是哭了，泪流满面，我全身细胞在放松，最后我们荣耀完了之后，我打包了一部分回来，我发现我是挺真爱想摸的，然而。那我们商量好之后，他要做出一些违背我
  • 剧本杀《鲸鱼马戏团》剧本杀剧透+真相答案复盘解析攻略 VX搜_奶茶剧本杀
    本文为剧本杀《鲸鱼马戏团》剧本杀测评+部分真相复盘，获取完整真相复盘只需两步：①、关注微信公众号【奶茶剧本杀】→②、回复剧本杀《鲸鱼马戏团》即可获取查看剧本杀《鲸鱼马戏团》剧本杀真相答案复盘+凶手剧透：以下是玩家评测+部分关键证据，凶手，时间线，复盘解析，推理逻辑--------------------------------------------------------------------
  • 下一站深圳 默琊
    昨天已经买好3/15到深圳的机票了，原本上周还有点拖延症发作，不太积极，所以昨天就直接逼迫自己买机票，然后在订房，下周就是确认行业和把具体的面谈日程定下来。行业的选择上目前没有太大的偏好，上一份工作主要是风控和客服，客服部分也算是个小组长，有负责培训和一些案件SOP流程的制定等工作。总感觉客服这个职位的职涯发展只能是垂直的往更高的管理层走，对于横向发展似乎不容易，而鉴于做客服1年的感受，我不太喜欢
  • 一比一复刻手表哪里可以买到？推荐三个可靠渠道 腕表世界
    在我国，提及一比一复刻手表，人们总是充满好奇与争议。这种高度仿真的复刻手表，凭借其精湛的工艺、时尚的设计，以及与正品相差无几的质感，深受一部分消费者的喜爱。但与此同时，其背后的侵权争议也一直不断。那么，究竟哪里可以买到这些令人心动的一比一复刻手表呢？腕表咨询微信：10428850一、何为一比一复刻手表？一比一复刻手表，指的是严格按照正版手表的设计、尺寸和工艺制作的仿制品。这些手表在材质、外观、功能
  • insert into select 主键自增_mybatis拦截器实现主键自动生成 weixin_39521651 insertintoselect主键自增mybatisdelete返回值mybatisinsert返回主键mybatisinsert返回对象mybatisplusinsert返回主键mybatisplus插入生成id
    前言前阵子和朋友聊天，他说他们项目有个需求，要实现主键自动生成，不想每次新增的时候，都手动设置主键。于是我就问他，那你们数据库表设置主键自动递增不就得了。他的回答是他们项目目前的id都是采用雪花算法来生成，因此为了项目稳定性，不会切换id的生成方式。朋友问我有没有什么实现思路，他们公司的orm框架是mybatis，我就建议他说，不然让你老大把mybatis切换成mybatis-plus。mybat
  • 三梦 | 心碎了还是醉了 培根不是肉
    今天，让我一起走进彝族火把节。图片发自App“中国彝族火把节之乡·2016布拖民间火把节”在离学校走约一个时辰路程的地方举行，奔着要在如此隆重的节日之中好好欣赏一番的目的，三梦团队一早便和随队的两个孩子整装待发。图片发自App第一部分:吉尔吉呷我万万没有想到，从踏出校门开始，从我牵上那个孩子的手开始，我心的触动就没有停过。图片发自App我以为我这一路会在观察、拍照和思考中度过，但我发现我错了。这个
  • 二分查找排序算法 周凡杨 java二分查找排序算法折半
    一：概念 二分查找又称 折半查找（ 折半搜索/ 二分搜索），优点是比较次数少，查找速度快，平均性能好；其缺点是要求待查表为有序表，且插入删除困难。因此，折半查找方法适用于不经常变动而 查找频繁的有序列表。首先，假设表中元素是按升序排列，将表中间位置记录的关键字与查找关键字比较，如果两者相等，则查找成功；否则利用中间位置记录将表 分成前、后两个子表，如果中间位置记录的关键字大于查找关键字，则进一步
  • java中的BigDecimal bijian1013 javaBigDecimal
            在项目开发过程中出现精度丢失问题，查资料用BigDecimal解决，并发现如下这篇BigDecimal的解决问题的思路和方法很值得学习，特转载。         原文地址：http://blog.csdn.net/ugg/article/de
  • Shell echo命令详解 daizj echoshell
    Shell echo命令 Shell 的 echo 指令与 PHP 的 echo 指令类似，都是用于字符串的输出。命令格式： echo string 您可以使用echo实现更复杂的输出格式控制。 1.显示普通字符串: echo "It is a test" 这里的双引号完全可以省略，以下命令与上面实例效果一致： echo Itis a test 2.显示转义
  • Oracle DBA 简单操作 周凡杨 oracle dba sql
    --执行次数多的SQL select sql_text,executions from (      select sql_text,executions from v$sqlarea order by executions desc      ) where rownum<81;  &nb
  • 画图重绘 朱辉辉33 游戏
      我第一次接触重绘是编写五子棋小游戏的时候，因为游戏里的棋盘是用线绘制的，而这些东西并不在系统自带的重绘里，所以在移动窗体时，棋盘并不会重绘出来。所以我们要重写系统的重绘方法。   在重写系统重绘方法时，我们要注意一定要调用父类的重绘方法，即加上super.paint(g)，因为如果不调用父类的重绘方式，重写后会把父类的重绘覆盖掉，而父类的重绘方法是绘制画布，这样就导致我们
  • 线程之初体验 西蜀石兰 线程
    一直觉得多线程是学Java的一个分水岭，懂多线程才算入门。 之前看《编程思想》的多线程章节，看的云里雾里，知道线程类有哪几个方法，却依旧不知道线程到底是什么？书上都写线程是进程的模块，共享线程的资源，可是这跟多线程编程有毛线的关系，呜呜。。。 线程其实也是用户自定义的任务，不要过多的强调线程的属性，而忽略了线程最基本的属性。 你可以在线程类的run()方法中定义自己的任务，就跟正常的Ja
  • linux集群互相免登陆配置 林鹤霄 linux
    配置ssh免登陆 1、生成秘钥和公钥    ssh-keygen -t rsa 2、提示让你输入，什么都不输，三次回车之后会在~下面的.ssh文件夹中多出两个文件id_rsa 和 id_rsa.pub    其中id_rsa为秘钥，id_rsa.pub为公钥，使用公钥加密的数据只有私钥才能对这些数据解密    c
  • mysql : Lock wait timeout exceeded; try restarting transaction aigo mysql
    原文：http://www.cnblogs.com/freeliver54/archive/2010/09/30/1839042.html   原因是你使用的InnoDB   表类型的时候, 默认参数:innodb_lock_wait_timeout设置锁等待的时间是50s, 因为有的锁等待超过了这个时间,所以抱错.   你可以把这个时间加长,或者优化存储
  • Socket编程 基本的聊天实现。 alleni123 socket
    public class Server { //用来存储所有连接上来的客户 private List<ServerThread> clients; public static void main(String[] args) { Server s = new Server(); s.startServer(9988); } publi
  • 多线程监听器事件模式(一个简单的例子) 百合不是茶 线程监听模式
        多线程的事件监听器模式   监听器时间模式经常与多线程使用,在多线程中如何知道我的线程正在执行那什么内容,可以通过时间监听器模式得到        创建多线程的事件监听器模式 思路:    1, 创建线程并启动,在创建线程的位置设置一个标记     2,创建队
  • spring InitializingBean接口 bijian1013 javaspring
    spring的事务的TransactionTemplate，其源码如下： public class TransactionTemplate extends DefaultTransactionDefinition implements TransactionOperations, InitializingBean{ ... } TransactionTemplate继承了DefaultT
  • Oracle中询表的权限被授予给了哪些用户 bijian1013 oracle数据库权限
            Oracle查询表将权限赋给了哪些用户的SQL，以备查用。 select t.table_name as "表名", t.grantee as "被授权的属组", t.owner as "对象所在的属组"
  • 【Struts2五】Struts2 参数传值 bit1129 struts2
    Struts2中参数传值的3种情况 1.请求参数绑定到Action的实例字段上 2.Action将值传递到转发的视图上 3.Action将值传递到重定向的视图上   一、请求参数绑定到Action的实例字段上以及Action将值传递到转发的视图上 Struts可以自动将请求URL中的请求参数或者表单提交的参数绑定到Action定义的实例字段上，绑定的规则使用ognl表达式语言
  • 【Kafka十四】关于auto.offset.reset[Q/A] bit1129 kafka
    I got serveral questions about  auto.offset.reset. This configuration parameter governs how  consumer read the message from  Kafka when  there is no initial offset in ZooKeeper or
  • nginx gzip压缩配置 ronin47 nginx gzip 压缩范例
    nginx gzip压缩配置 更多 0 nginx gzip 配置   随着nginx的发展，越来越多的网站使用nginx，因此nginx的优化变得越来越重要，今天我们来看看nginx的gzip压缩到底是怎么压缩的呢？ gzip(GNU-ZIP)是一种压缩技术。经过gzip压缩后页面大小可以变为原来的30%甚至更小，这样，用
  • java-13.输入一个单向链表，输出该链表中倒数第 k 个节点 bylijinnan java
    two cursors. Make the first cursor go K steps first. /* * 第 13 题：题目：输入一个单向链表，输出该链表中倒数第 k 个节点 */ public void displayKthItemsBackWard(ListNode head,int k){ ListNode p1=head,p2=head;
  • Spring源码学习-JdbcTemplate queryForObject bylijinnan javaspring
    JdbcTemplate中有两个可能会混淆的queryForObject方法： 1. Object queryForObject(String sql, Object[] args, Class requiredType) 2. Object queryForObject(String sql, Object[] args, RowMapper rowMapper) 第1个方法是只查
  • [冰川时代]在冰川时代,我们需要什么样的技术? comsci 技术
         看美国那边的气候情况....我有个感觉...是不是要进入小冰期了?      那么在小冰期里面...我们的户外活动肯定会出现很多问题...在室内呆着的情况会非常多...怎么在室内呆着而不发闷...怎么用最低的电力保证室内的温度.....这都需要技术手段...   &nb
  • js 获取浏览器型号 cuityang js浏览器
    根据浏览器获取iphone和apk的下载地址 <!DOCTYPE html> <html> <head>     <meta charset="utf-8" content="text/html"/>     <meta name=
  • C# socks5详解 转 dalan_123 socketC#
    http://www.cnblogs.com/zhujiechang/archive/2008/10/21/1316308.html  这里主要讲的是用.NET实现基于Socket5下面的代理协议进行客户端的通讯，Socket4的实现是类似的，注意的事，这里不是讲用C#实现一个代理服务器，因为实现一个代理服务器需要实现很多协议，头大，而且现在市面上有很多现成的代理服务器用，性能又好，
  • 运维 Centos问题汇总 dcj3sjt126com 云主机
    一、sh 脚本不执行的原因 sh脚本不执行的原因 只有2个 1.权限不够 2.sh脚本里路径没写完整。   二、解决You have new mail in /var/spool/mail/root 修改/usr/share/logwatch/default.conf/logwatch.conf配置文件 MailTo = MailFrom   三、查询连接数
  • Yii防注入攻击笔记 dcj3sjt126com sqlWEB安全yii
    网站表单有注入漏洞须对所有用户输入的内容进行个过滤和检查，可以使用正则表达式或者直接输入字符判断，大部分是只允许输入字母和数字的，其它字符度不允许；对于内容复杂表单的内容，应该对html和script的符号进行转义替换：尤其是<,>,',"",&这几个符号 这里有个转义对照表： http://blog.csdn.net/xinzhu1990/articl
  • MongoDB简介[一] eksliang mongodbMongoDB简介
    MongoDB简介 转载请出自出处：http://eksliang.iteye.com/blog/2173288 1.1易于使用        MongoDB是一个面向文档的数据库，而不是关系型数据库。与关系型数据库相比，面向文档的数据库不再有行的概念，取而代之的是更为灵活的“文档”模型。        另外，不
  • zookeeper windows 入门安装和测试 greemranqq zookeeper安装分布式
    一、序言       以下是我对zookeeper 的一些理解：      zookeeper 作为一个服务注册信息存储的管理工具，好吧，这样说得很抽象，我们举个“栗子”。       栗子1号：       假设我是一家KTV的老板，我同时拥有5家KTV，我肯定得时刻监视
  • Spring之使用事务缘由(2-注解实现) ihuning spring
      Spring事务注解实现   1. 依赖包：     1.1 spring包：           spring-beans-4.0.0.RELEASE.jar           spring-context-4.0.0.
  • iOS App Launch Option 啸笑天 option
    iOS 程序启动时总会调用application:didFinishLaunchingWithOptions:，其中第二个参数launchOptions为NSDictionary类型的对象，里面存储有此程序启动的原因。   launchOptions中的可能键值见UIApplication Class Reference的Launch Options Keys节 。 1、若用户直接
  • jdk与jre的区别（_） macroli javajvmjdk
    简单的说JDK是面向开发人员使用的SDK，它提供了Java的开发环境和运行环境。SDK是Software Development Kit 一般指软件开发包，可以包括函数库、编译程序等。  JDK就是Java Development Kit JRE是Java Runtime Enviroment是指Java的运行环境，是面向Java程序的使用者，而不是开发者。 如果安装了JDK，会发同你
  • Updates were rejected because the tip of your current branch is behind qiaolevip 学习永无止境每天进步一点点众观千象git
    $ git push joe prod-2295-1 To [email protected]:joe.le/dr-frontend.git ! [rejected] prod-2295-1 -> prod-2295-1 (non-fast-forward) error: failed to push some refs to '[email protected]
  • [一起学Hive]之十四-Hive的元数据表结构详解 superlxw1234 hivehive元数据结构
    关键字：Hive元数据、Hive元数据表结构   之前在 “[一起学Hive]之一–Hive概述，Hive是什么”中介绍过，Hive自己维护了一套元数据，用户通过HQL查询时候，Hive首先需要结合元数据，将HQL翻译成MapReduce去执行。 本文介绍一下Hive元数据中重要的一些表结构及用途，以Hive0.13为例。   文章最后面，会以一个示例来全面了解一下，
  • Spring 3.2.14，4.1.7，4.2.RC2发布 wiselyman Spring 3
      Spring 3.2.14、4.1.7及4.2.RC2于6月30日发布。   其中Spring 3.2.1是一个维护版本(维护周期到2016-12-31截止)，后续会继续根据需求和bug发布维护版本。此时，Spring官方强烈建议升级Spring框架至4.1.7 或者将要发布的4.2 。   其中Spring 4.1.7主要包含这些更新内容。
按字母分类： ABCDEFGHIJKLMNOPQRSTUVWXYZ其他