一. HttpClient详细使用示例

HTTP 协议可能是现在 Internet 上使用得最多、最重要的协议了，越来越多的 Java 应用程序需要直接通过 HTTP 协议来访问网络资源。虽然在 JDK 的 java net包中已经提供了访问 HTTP 协议的基本功能，但是对于大部分应用程序来说，JDK 库本身提供的功能还不够丰富和灵活。HttpClient 是 Apache Jakarta Common 下的子项目，用来提供高效的、最新的、功能丰富的支持 HTTP 协议的客户端编程工具包，并且它支持 HTTP 协议最新的版本和建议。

HTTP和浏览器有点像，但却不是浏览器。很多人觉得既然HttpClient是一个HTTP客户端编程工具，很多人把他当做浏览器来理解，但是其实HttpClient不是浏览器，它是一个HTTP通信库，因此它只提供一个通用浏览器应用程序所期望的功能子集，最根本的区别是HttpClient中没有用户界面，浏览器需要一个渲染引擎来显示页面，并解释用户输入，例如鼠标点击显示页面上的某处，有一个布局引擎，计算如何显示HTML页面，包括级联样式表和图像。javascript解释器运行嵌入HTML页面或从HTML页面引用的javascript代码。来自用户界面的事件被传递到javascript解释器进行处理。除此之外，还有用于插件的接口，可以处理Applet，嵌入式媒体对象（如pdf文件，Quicktime电影和Flash动画）或ActiveX控件（可以执行任何操作）。HttpClient只能以编程的方式通过其API用于传输和接受HTTP消息。

HttpClient的主要功能：

• 实现了所有 HTTP 的方法（GET、POST、PUT、HEAD、DELETE、HEAD、OPTIONS 等）
• 支持 HTTPS 协议
• 支持代理服务器（Nginx等）等
• 支持自动（跳转）转向
• ……

环境说明：JDK1.8、SpringBoot

准备环节

第一步：引入HttpClient的依赖

<dependency>
    <groupId>org.apache.httpcomponents</groupId>
    <artifactId>httpclient</artifactId>
    <version>4.5.5</version>
</dependency>

第二步：引入fastjson依赖

<dependency>
    <groupId>com.alibaba</groupId>
    <artifactId>fastjson</artifactId>
    <version>1.2.47</version>
</dependency>

注：本人引入此依赖的目的是，在后续示例中，会用到“将对象转化为json字符串的功能”，也可以引其他有此功能的依赖。

注：SpringBoot的基本依赖配置，这里就不再多说了。

详细使用示例

声明：此示例中，以JAVA发送HttpClient(在test里面单元测试发送的)；也是以JAVA接收的（在controller里面接收的）。

声明：下面的代码，本人亲测有效。

1. GET无参：

HttpClient发送示例：

/**
     * GET---无参测试
     *
     * @date 2018年7月13日 下午4:18:50
     */
@Test
public void doGetTestOne() {
    // 获得Http客户端(可以理解为:你得先有一个浏览器;注意:实际上HttpClient与浏览器是不一样的)
    CloseableHttpClient httpClient = HttpClientBuilder.create().build();
    // 创建Get请求
    HttpGet httpGet = new HttpGet("http://localhost:12345/doGetControllerOne");

    // 响应模型
    CloseableHttpResponse response = null;
    try {
        // 由客户端执行(发送)Get请求
        response = httpClient.execute(httpGet);
        // 从响应模型中获取响应实体
        HttpEntity responseEntity = response.getEntity();
        System.out.println("响应状态为:" + response.getStatusLine());
        if (responseEntity != null) {
            System.out.println("响应内容长度为:" + responseEntity.getContentLength());
            System.out.println("响应内容为:" + EntityUtils.toString(responseEntity));
        }
    } catch (ClientProtocolException e) {
        e.printStackTrace();
    } catch (ParseException e) {
        e.printStackTrace();
    } catch (IOException e) {
        e.printStackTrace();
    } finally {
        try {
            // 释放资源
            if (httpClient != null) {
                httpClient.close();
            }
            if (response != null) {
                response.close();
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

对应接收示例：

2.GET有参(方式一：直接拼接URL)：

HttpClient发送示例：

/**
     * GET---有参测试 (方式一:手动在url后面加上参数)
     *
     * @date 2018年7月13日 下午4:19:23
     */
@Test
public void doGetTestWayOne() {
    // 获得Http客户端(可以理解为:你得先有一个浏览器;注意:实际上HttpClient与浏览器是不一样的)
    CloseableHttpClient httpClient = HttpClientBuilder.create().build();

    // 参数
    StringBuffer params = new StringBuffer();
    try {
        // 字符数据最好encoding以下;这样一来，某些特殊字符才能传过去(如:某人的名字就是“&”,不encoding的话,传不过去)
        params.append("name=" + URLEncoder.encode("&", "utf-8"));
        params.append("&");
        params.append("age=24");
    } catch (UnsupportedEncodingException e1) {
        e1.printStackTrace();
    }

    // 创建Get请求
    HttpGet httpGet = new HttpGet("http://localhost:12345/doGetControllerTwo" + "?" + params);
    // 响应模型
    CloseableHttpResponse response = null;
    try {
        // 配置信息
        RequestConfig requestConfig = RequestConfig.custom()
            // 设置连接超时时间(单位毫秒)
            .setConnectTimeout(5000)
            // 设置请求超时时间(单位毫秒)
            .setConnectionRequestTimeout(5000)
            // socket读写超时时间(单位毫秒)
            .setSocketTimeout(5000)
            // 设置是否允许重定向(默认为true)
            .setRedirectsEnabled(true).build();

        // 将上面的配置信息 运用到这个Get请求里
        httpGet.setConfig(requestConfig);

        // 由客户端执行(发送)Get请求
        response = httpClient.execute(httpGet);

        // 从响应模型中获取响应实体
        HttpEntity responseEntity = response.getEntity();
        System.out.println("响应状态为:" + response.getStatusLine());
        if (responseEntity != null) {
            System.out.println("响应内容长度为:" + responseEntity.getContentLength());
            System.out.println("响应内容为:" + EntityUtils.toString(responseEntity));
        }
    } catch (ClientProtocolException e) {
        e.printStackTrace();
    } catch (ParseException e) {
        e.printStackTrace();
    } catch (IOException e) {
        e.printStackTrace();
    } finally {
        try {
            // 释放资源
            if (httpClient != null) {
                httpClient.close();
            }
            if (response != null) {
                response.close();
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

对应接收示例：

3. GET有参(方式二：使用URI获得HttpGet)：

HttpClient发送示例：

/**
     * GET---有参测试 (方式二:将参数放入键值对类中,再放入URI中,从而通过URI得到HttpGet实例)
     *
     * @date 2018年7月13日 下午4:19:23
     */
@Test
public void doGetTestWayTwo() {
    // 获得Http客户端(可以理解为:你得先有一个浏览器;注意:实际上HttpClient与浏览器是不一样的)
    CloseableHttpClient httpClient = HttpClientBuilder.create().build();

    // 参数
    URI uri = null;
    try {
        // 将参数放入键值对类NameValuePair中,再放入集合中
        List<NameValuePair> params = new ArrayList<>();
        params.add(new BasicNameValuePair("name", "&"));
        params.add(new BasicNameValuePair("age", "18"));
        // 设置uri信息,并将参数集合放入uri;
        // 注:这里也支持一个键值对一个键值对地往里面放setParameter(String key, String value)
        uri = new URIBuilder().setScheme("http").setHost("localhost")
            .setPort(12345).setPath("/doGetControllerTwo")
            .setParameters(params).build();
    } catch (URISyntaxException e1) {
        e1.printStackTrace();
    }
    // 创建Get请求
    HttpGet httpGet = new HttpGet(uri);

    // 响应模型
    CloseableHttpResponse response = null;
    try {
        // 配置信息
        RequestConfig requestConfig = RequestConfig.custom()
            // 设置连接超时时间(单位毫秒)
            .setConnectTimeout(5000)
            // 设置请求超时时间(单位毫秒)
            .setConnectionRequestTimeout(5000)
            // socket读写超时时间(单位毫秒)
            .setSocketTimeout(5000)
            // 设置是否允许重定向(默认为true)
            .setRedirectsEnabled(true).build();

        // 将上面的配置信息 运用到这个Get请求里
        httpGet.setConfig(requestConfig);

        // 由客户端执行(发送)Get请求
        response = httpClient.execute(httpGet);

        // 从响应模型中获取响应实体
        HttpEntity responseEntity = response.getEntity();
        System.out.println("响应状态为:" + response.getStatusLine());
        if (responseEntity != null) {
            System.out.println("响应内容长度为:" + responseEntity.getContentLength());
            System.out.println("响应内容为:" + EntityUtils.toString(responseEntity));
        }
    } catch (ClientProtocolException e) {
        e.printStackTrace();
    } catch (ParseException e) {
        e.printStackTrace();
    } catch (IOException e) {
        e.printStackTrace();
    } finally {
        try {
            // 释放资源
            if (httpClient != null) {
                httpClient.close();
            }
            if (response != null) {
                response.close();
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

对应接收示例：

4. POST无参：

HttpClient发送示例：

/**
     * POST---无参测试
     *
     * @date 2018年7月13日 下午4:18:50
     */
@Test
public void doPostTestOne() {

    // 获得Http客户端(可以理解为:你得先有一个浏览器;注意:实际上HttpClient与浏览器是不一样的)
    CloseableHttpClient httpClient = HttpClientBuilder.create().build();

    // 创建Post请求
    HttpPost httpPost = new HttpPost("http://localhost:12345/doPostControllerOne");
    // 响应模型
    CloseableHttpResponse response = null;
    try {
        // 由客户端执行(发送)Post请求
        response = httpClient.execute(httpPost);
        // 从响应模型中获取响应实体
        HttpEntity responseEntity = response.getEntity();

        System.out.println("响应状态为:" + response.getStatusLine());
        if (responseEntity != null) {
            System.out.println("响应内容长度为:" + responseEntity.getContentLength());
            System.out.println("响应内容为:" + EntityUtils.toString(responseEntity));
        }
    } catch (ClientProtocolException e) {
        e.printStackTrace();
    } catch (ParseException e) {
        e.printStackTrace();
    } catch (IOException e) {
        e.printStackTrace();
    } finally {
        try {
            // 释放资源
            if (httpClient != null) {
                httpClient.close();
            }
            if (response != null) {
                response.close();
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

对应接收示例：

5. POST有参(普通参数)：

注：POST传递普通参数时，方式与GET一样即可，这里以直接在url后缀上参数的方式示例。

HttpClient发送示例：

/**
     * POST---有参测试(普通参数)
     *
     * @date 2018年7月13日 下午4:18:50
     */
@Test
public void doPostTestFour() {

    // 获得Http客户端(可以理解为:你得先有一个浏览器;注意:实际上HttpClient与浏览器是不一样的)
    CloseableHttpClient httpClient = HttpClientBuilder.create().build();

    // 参数
    StringBuffer params = new StringBuffer();
    try {
        // 字符数据最好encoding以下;这样一来，某些特殊字符才能传过去(如:某人的名字就是“&”,不encoding的话,传不过去)
        params.append("name=" + URLEncoder.encode("&", "utf-8"));
        params.append("&");
        params.append("age=24");
    } catch (UnsupportedEncodingException e1) {
        e1.printStackTrace();
    }

    // 创建Post请求
    HttpPost httpPost = new HttpPost("http://localhost:12345/doPostControllerFour" + "?" + params);

    // 设置ContentType(注:如果只是传普通参数的话,ContentType不一定非要用application/json)
    httpPost.setHeader("Content-Type", "application/json;charset=utf8");

    // 响应模型
    CloseableHttpResponse response = null;
    try {
        // 由客户端执行(发送)Post请求
        response = httpClient.execute(httpPost);
        // 从响应模型中获取响应实体
        HttpEntity responseEntity = response.getEntity();

        System.out.println("响应状态为:" + response.getStatusLine());
        if (responseEntity != null) {
            System.out.println("响应内容长度为:" + responseEntity.getContentLength());
            System.out.println("响应内容为:" + EntityUtils.toString(responseEntity));
        }
    } catch (ClientProtocolException e) {
        e.printStackTrace();
    } catch (ParseException e) {
        e.printStackTrace();
    } catch (IOException e) {
        e.printStackTrace();
    } finally {
        try {
            // 释放资源
            if (httpClient != null) {
                httpClient.close();
            }
            if (response != null) {
                response.close();
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

对应接收示例：

6. POST有参(对象参数)：

先给出User类

HttpClient发送示例：

/**
     * POST---有参测试(对象参数)
     *
     * @date 2018年7月13日 下午4:18:50
     */
@Test
public void doPostTestTwo() {

    // 获得Http客户端(可以理解为:你得先有一个浏览器;注意:实际上HttpClient与浏览器是不一样的)
    CloseableHttpClient httpClient = HttpClientBuilder.create().build();

    // 创建Post请求
    HttpPost httpPost = new HttpPost("http://localhost:12345/doPostControllerTwo");
    User user = new User();
    user.setName("潘晓婷");
    user.setAge(18);
    user.setGender("女");
    user.setMotto("姿势要优雅~");
    // 我这里利用阿里的fastjson，将Object转换为json字符串;
    // (需要导入com.alibaba.fastjson.JSON包)
    String jsonString = JSON.toJSONString(user);

    StringEntity entity = new StringEntity(jsonString, "UTF-8");

    // post请求是将参数放在请求体里面传过去的;这里将entity放入post请求体中
    httpPost.setEntity(entity);

    httpPost.setHeader("Content-Type", "application/json;charset=utf8");

    // 响应模型
    CloseableHttpResponse response = null;
    try {
        // 由客户端执行(发送)Post请求
        response = httpClient.execute(httpPost);
        // 从响应模型中获取响应实体
        HttpEntity responseEntity = response.getEntity();

        System.out.println("响应状态为:" + response.getStatusLine());
        if (responseEntity != null) {
            System.out.println("响应内容长度为:" + responseEntity.getContentLength());
            System.out.println("响应内容为:" + EntityUtils.toString(responseEntity));
        }
    } catch (ClientProtocolException e) {
        e.printStackTrace();
    } catch (ParseException e) {
        e.printStackTrace();
    } catch (IOException e) {
        e.printStackTrace();
    } finally {
        try {
            // 释放资源
            if (httpClient != null) {
                httpClient.close();
            }
            if (response != null) {
                response.close();
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

对应接收示例：

7. POST有参(普通参数 + 对象参数)：

注：POST传递普通参数时，方式与GET一样即可，这里以通过URI获得HttpPost的方式为例。

先给出User类：同上

HttpClient发送示例：

/**
     * POST---有参测试(普通参数 + 对象参数)
     *
     * @date 2018年7月13日 下午4:18:50
     */
@Test
public void doPostTestThree() {

    // 获得Http客户端(可以理解为:你得先有一个浏览器;注意:实际上HttpClient与浏览器是不一样的)
    CloseableHttpClient httpClient = HttpClientBuilder.create().build();

    // 创建Post请求
    // 参数
    URI uri = null;
    try {
        // 将参数放入键值对类NameValuePair中,再放入集合中
        List<NameValuePair> params = new ArrayList<>();
        params.add(new BasicNameValuePair("flag", "4"));
        params.add(new BasicNameValuePair("meaning", "这是什么鬼？"));
        // 设置uri信息,并将参数集合放入uri;
        // 注:这里也支持一个键值对一个键值对地往里面放setParameter(String key, String value)
        uri = new URIBuilder().setScheme("http").setHost("localhost").setPort(12345)
            .setPath("/doPostControllerThree").setParameters(params).build();
    } catch (URISyntaxException e1) {
        e1.printStackTrace();
    }

    HttpPost httpPost = new HttpPost(uri);
    // HttpPost httpPost = new
    // HttpPost("http://localhost:12345/doPostControllerThree1");

    // 创建user参数
    User user = new User();
    user.setName("潘晓婷");
    user.setAge(18);
    user.setGender("女");
    user.setMotto("姿势要优雅~");

    // 将user对象转换为json字符串，并放入entity中
    StringEntity entity = new StringEntity(JSON.toJSONString(user), "UTF-8");

    // post请求是将参数放在请求体里面传过去的;这里将entity放入post请求体中
    httpPost.setEntity(entity);

    httpPost.setHeader("Content-Type", "application/json;charset=utf8");

    // 响应模型
    CloseableHttpResponse response = null;
    try {
        // 由客户端执行(发送)Post请求
        response = httpClient.execute(httpPost);
        // 从响应模型中获取响应实体
        HttpEntity responseEntity = response.getEntity();

        System.out.println("响应状态为:" + response.getStatusLine());
        if (responseEntity != null) {
            System.out.println("响应内容长度为:" + responseEntity.getContentLength());
            System.out.println("响应内容为:" + EntityUtils.toString(responseEntity));
        }
    } catch (ClientProtocolException e) {
        e.printStackTrace();
    } catch (ParseException e) {
        e.printStackTrace();
    } catch (IOException e) {
        e.printStackTrace();
    } finally {
        try {
            // 释放资源
            if (httpClient != null) {
                httpClient.close();
            }
            if (response != null) {
                response.close();
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

对应接收示例：

解决响应乱码问题(示例)：

进行HTTPS请求并进行(或不进行)证书校验(示例)：

application/x-www-form-urlencoded表单请求(示例)：

发送文件(示例)：

发送流(示例)：

以上参考文章

二. 使用httpclient post请求中文乱码解决办法

在使用httpclient发送post请求的时候，接收端中文乱码问题解决。

我们都知道，一般情况下使用post请求是不会出现中文乱码的。可是在使用httpclient发送post请求报文含中文的时候在发送端数据正常但是到了服务器端就中文乱码了。

解决办法：

发送端进行设置编码如下：

主要代码：

if (null != jsonParam) {
    //解决中文问题。
    method.addHeader("Content-type","application/json; charset=utf-8");
    method.setHeader("Accept", "application/json");
    method.setEntity(new StringEntity(jsonParam.toString(), Charset.forName("UTF-8")));
}

HttpResponse result = httpClient.execute(method);

在接收(服务器)端：

主要代码：

@RequestMapping(value = "getJson")
@ResponseBody
public Map<String,Object> getJson(@RequestBody String requestBody, HttpServletRequest request){
    requestBody = new String(requestBody.getBytes(), Charset.forName("utf-8"));
    JSONObject jsonObject = JSONObject.parseObject(requestBody);
    System.out.println(jsonObject);
    ResultJsonInfo info = JSONObject.parseObject(jsonObject.toJSONString(), ResultJsonInfo.class);
    System.out.println(info);
    //TODO 处理自己业务
    JSONObject result= new JSONObject();
    result.put("success", "true");
    Map<String, Object> resultMap = new HashMap<String, Object>();
    resultMap.put("isok", true);
    return resultMap;
}

三. java根据当前日期返回上周日期方法

需求：

1. 可以通过本方法获取上周的数据添加到本周
2. 获取的数据中日期是上周的需要添加一周

/**
     * 根据当前日期返回上周日期(yyyy-mm-dd)
     * @param nowDay 当前日期
     * @param i     -1：表示上周，1表示下周
     * @return
     */
public String getWeekDay(String nowDay,int i) {
    Date date = null;
    try {
        date = DateUtils.getDate(nowDay, DateConst.HYPHEN_DISPLAY_DATE);
    } catch (ParseException e) {
        e.printStackTrace();
    }
    Calendar calendar = Calendar.getInstance();
    calendar.setTime(date);
    calendar.add(Calendar.WEEK_OF_YEAR, i);
    return DateUtils.getTimeStr(calendar.getTime(), DateConst.HYPHEN_DISPLAY_DATE);
}

四. Spring请求异常问题

异常信息：

MissingServletRequestParameterException: Required xxx parameter ‘xxx’ is not present

报错原因：

Controller中的接受参数

// 下面的对传入参数指定为 xttblog，如果前端不传 xttblog 参数名，会报错 
public String function(@RequestParam(value="xttblog") String xttblog){
    ......
}

错误信息如下：

HTTP Status 400 – Required String parameter 'xttblog' is not present

@RequestParam 还有一个 required 属性，当我们配置 required 参数后，上面的代码就不会报错了。

通过 required=false 或者 required=true 来要求 @RequestParam配置的前端参数是否一定要传。required=false 表示不传的话，会给参数赋值为 null，required=true 就是必须要有。

如果注解的参数是 int 基本类型，这时再用 required=false，就会报错，因为不传值，把 null 赋值给 int，肯定会报错。具体的错误如下：

“Consider declaring it as object wrapper for the corresponding primitive type.”

要解决这个错误也很简单。就是把基本数据类型改为包装数据类型即可。如 int 改为 Integer。

五. 内存溢出

在tomcat的启动文件中加上

export JAVA_OPTS="-XX:PermSize=2048m -Xms20g -Xmx20g -XX:+UseG1GC"

六. 如何使用start with connect by prior递归用法

1. Oracle中start with…connect by prior子句用法

connect by 是结构化查询中用到的，其基本语法是

select … from tablename
start with 条件1
connect by 条件2
where 条件3;

例：

select * from table
start with org_id = ‘HBHqfWGWPy’
connect by prior org_id = parent_id;

简单说来是将一个树状结构存储在一张表里，比如一个表中存在两个字段:
org_id，parent_id那么通过表示每一条记录的parent是谁，就可以形成一个树状结构。

用上述语法的查询可以取得这棵树的所有记录。

其中：

条件1 是根结点的限定语句，当然可以放宽限定条件，以取得多个根结点，实际就是多棵树。
条件2 是连接条件，其中用PRIOR表示上一条记录，比如 CONNECT BY PRIOR org_id = parent_id；就是说上一条记录的org_id 是本条记录的parent_id，即本记录的父亲是上一条记录。
条件3 是过滤条件，用于对返回的所有记录进行过滤。

简单介绍如下：
在扫描树结构表时，需要依此访问树结构的每个节点，一个节点只能访问一次，其访问的步骤如下：

• 第一步：从根节点开始；
  

• 第二步：访问该节点；
  

• 第三步：判断该节点有无未被访问的子节点，若有，则转向它最左侧的未被访问的子节，并执行第二步，否则执行第四步；
  

• 第四步：若该节点为根节点，则访问完毕，否则执行第五步；
  

• 第五步：返回到该节点的父节点，并执行第三步骤。
  

  总之：扫描整个树结构的过程也即是中序遍历树的过程。

1.1 树结构的描述

树结构的数据存放在表中，数据之间的层次关系即父子关系，通过表中的列与列间的关系来描述，如EMP表中的EMPNO和MGR。EMPNO表示该雇员的编号，MGR表示领导该雇员的人的编号，即子节点的MGR值等于父节点的EMPNO值。在表的每一行中都有一个表示父节点的MGR（除根节点外），通过每个节点的父节点，就可以确定整个树结构。

在SELECT命令中使用CONNECT BY 和START WITH 子句可以查询表中的树型结构关系。其命令格式如下：

SELECT . . .
CONNECT BY {PRIOR 列名1=列名2|列名1=PRIOR 裂名2}
[START WITH]；

其中：CONNECT BY子句说明每行数据将是按层次顺序检索，并规定将表中的数据连入树型结构的关系中。PRIOR运算符必须放置在连接关系的两列中某一个的前面。对于节点间的父子关系，PRIOR运算符在一侧表示父节点，在另一侧表示子节点，从而确定查找树结构是的顺序是自顶向下还是自底向上。

在连接关系中，除了可以使用列名外，还允许使用列表达式。START WITH 子句为可选项，用来标识哪个节点作为查找树型结构的根节点。若该子句被省略，则表示所有满足查询条件的行作为根节点。

START WITH：不但可以指定一个根节点，还可以指定多个根节点。

1.2 关于PRIOR

运算符PRIOR被放置于等号前后的位置，决定着查询时的检索顺序。

PRIOR被置于CONNECT BY子句中等号的前面时，则强制从根节点到叶节点的顺序检索，即由父节点向子节点方向通过树结构，我们称之为自顶向下的方式。如：

 CONNECT BY PRIOR EMPNO=MGR

 PIROR运算符被置于CONNECT BY 子句中等号的后面时，则强制从叶节点到根节点的顺序检索，即由子节点向父节点方向通过树结构，我们称之为自底向上的方式。例如：

 CONNECT BY EMPNO=PRIOR MGR
 在这种方式中也应指定一个开始的节点。

1.3 定义查找起始节点

在自顶向下查询树结构时，不但可以从根节点开始，还可以定义任何节点为起始节点，以此开始向下查找。这样查找的结果就是以该节点为开始的结构树的一枝。

1.4 使用LEVEL

在具有树结构的表中，每一行数据都是树结构中的一个节点，由于节点所处的层次位置不同，所以每行记录都可以有一个层号。层号根据节点与根节点的距离确定。不论从哪个节点开始，该起始根节点的层号始终为1，根节点的子节点为2， 依此类推。图1.2就表示了树结构的层次。

1.5 节点和分支的裁剪

在对树结构进行查询时，可以去掉表中的某些行，也可以剪掉树中的一个分支，使用WHERE子句来限定树型结构中的单个节点，以去掉树中的单个节点，但它却不影响其后代节点（自顶向下检索时）或前辈节点（自底向顶检索时）。

1.6 排序显示

象在其它查询中一样，在树结构查询中也可以使用ORDER BY 子句，改变查询结果的显示顺序，而不必按照遍历树结构的顺序。

2. 例子

2.1 准备测试表和测试数据

--菜单目录结构表
create table tb_menu(
   id     number(10) not null, --主键id
   title  varchar2(50), --标题
   parent number(10) --parent id
)
 
--父菜单
insert into tb_menu(id, title, parent) values(1, '父菜单1',null);
insert into tb_menu(id, title, parent) values(2, '父菜单2',null);
insert into tb_menu(id, title, parent) values(3, '父菜单3',null);
insert into tb_menu(id, title, parent) values(4, '父菜单4',null);
insert into tb_menu(id, title, parent) values(5, '父菜单5',null);
--一级菜单
insert into tb_menu(id, title, parent) values(6, '一级菜单6',1);
insert into tb_menu(id, title, parent) values(7, '一级菜单7',1);
insert into tb_menu(id, title, parent) values(8, '一级菜单8',1);
insert into tb_menu(id, title, parent) values(9, '一级菜单9',2);
insert into tb_menu(id, title, parent) values(10, '一级菜单10',2);
insert into tb_menu(id, title, parent) values(11, '一级菜单11',2);
insert into tb_menu(id, title, parent) values(12, '一级菜单12',3);
insert into tb_menu(id, title, parent) values(13, '一级菜单13',3);
insert into tb_menu(id, title, parent) values(14, '一级菜单14',3);
insert into tb_menu(id, title, parent) values(15, '一级菜单15',4);
insert into tb_menu(id, title, parent) values(16, '一级菜单16',4);
insert into tb_menu(id, title, parent) values(17, '一级菜单17',4);
insert into tb_menu(id, title, parent) values(18, '一级菜单18',5);
insert into tb_menu(id, title, parent) values(19, '一级菜单19',5);
insert into tb_menu(id, title, parent) values(20, '一级菜单20',5);
--二级菜单
insert into tb_menu(id, title, parent) values(21, '二级菜单21',6);
insert into tb_menu(id, title, parent) values(22, '二级菜单22',6);
insert into tb_menu(id, title, parent) values(23, '二级菜单23',7);
insert into tb_menu(id, title, parent) values(24, '二级菜单24',7);
insert into tb_menu(id, title, parent) values(25, '二级菜单25',8);
insert into tb_menu(id, title, parent) values(26, '二级菜单26',9);
insert into tb_menu(id, title, parent) values(27, '二级菜单27',10);
insert into tb_menu(id, title, parent) values(28, '二级菜单28',11);
insert into tb_menu(id, title, parent) values(29, '二级菜单29',12);
insert into tb_menu(id, title, parent) values(30, '二级菜单30',13);
insert into tb_menu(id, title, parent) values(31, '二级菜单31',14);
insert into tb_menu(id, title, parent) values(32, '二级菜单32',15);
insert into tb_menu(id, title, parent) values(33, '二级菜单33',16);
insert into tb_menu(id, title, parent) values(34, '二级菜单34',17);
insert into tb_menu(id, title, parent) values(35, '二级菜单35',18);
insert into tb_menu(id, title, parent) values(36, '二级菜单36',19);
insert into tb_menu(id, title, parent) values(37, '二级菜单37',20);
--三级菜单
insert into tb_menu(id, title, parent) values(38, '三级菜单38',21);
insert into tb_menu(id, title, parent) values(39, '三级菜单39',22);
insert into tb_menu(id, title, parent) values(40, '三级菜单40',23);
insert into tb_menu(id, title, parent) values(41, '三级菜单41',24);
insert into tb_menu(id, title, parent) values(42, '三级菜单42',25);
insert into tb_menu(id, title, parent) values(43, '三级菜单43',26);
insert into tb_menu(id, title, parent) values(44, '三级菜单44',27);
insert into tb_menu(id, title, parent) values(45, '三级菜单45',28);
insert into tb_menu(id, title, parent) values(46, '三级菜单46',28);
insert into tb_menu(id, title, parent) values(47, '三级菜单47',29);
insert into tb_menu(id, title, parent) values(48, '三级菜单48',30);
insert into tb_menu(id, title, parent) values(49, '三级菜单49',31);
insert into tb_menu(id, title, parent) values(50, '三级菜单50',31);
commit;
 
select * from tb_menu;

parent字段存储的是上级id，如果是顶级父节点，该parent为null(得补充一句，当初的确是这样设计的，不过现在知道，表中最好别有null记录，这会引起全文扫描，建议改成0代替)。

2.2 树操作

我们从最基本的操作，逐步列出树查询中常见的操作，所有查询出来的节点以家族中的辈份作比方。

查找树中的所有顶级父节点（辈份最长的人）。 假设这个树是个目录结构，那么第一个操作总是找出所有的顶级节点，再根据该节点找到其下属节点。

select * from tb_menu m where m.parent is null;

查找一个节点的直属子节点（所有儿子）。 如果查找的是直属子类节点，也是不用用到树型查询的。

select * from tb_menu m where m.parent=1;

查找一个节点的所有直属子节点（所有后代）。

select * from tb_menu m start with m.id=1 connect by m.parent=prior m.id;

这个查找的是id为1的节点下的所有直属子类节点，包括子辈的和孙子辈的所有直属节点。

查找一个节点的直属父节点（父亲）。 如果查找的是节点的直属父节点，也是不用用到树型查询的。

--c-->child, p->parent
select c.id, c.title, p.id parent_id, p.title parent_title
from tb_menu c, tb_menu p
where c.parent=p.id and c.id=6

查找一个节点的所有直属父节点（祖宗）。

select * from tb_menu m start with m.id=38 connect by prior m.parent=m.id;

这里查找的就是id为1的所有直属父节点，打个比方就是找到一个人的父亲、祖父等。但是值得注意的是这个查询出来的结果的顺序是先列出子类节点再列出父类节点，姑且认为是个倒序吧。

上面列出两个树型查询方式，第3条语句和第5条语句，这两条语句之间的区别在于prior关键字的位置不同，所以决定了查询的方式不同。 当parent = prior id时，数据库会根据当前的id迭代出parent与该id相同的记录，所以查询的结果是迭代出了所有的子类记录；而prior parent = id时，数据库会跟据当前的parent来迭代出与当前的parent相同的id的记录，所以查询出来的结果就是所有的父类结果。

以下是一系列针对树结构的更深层次的查询，这里的查询不一定是最优的查询方式，或许只是其中的一种实现而已。

查询一个节点的兄弟节点（亲兄弟）。

--m.parent=m2.parent-->同一个父亲
select * from tb_menu m
where exists (select * from tb_menu m2 where m.parent=m2.parent and m2.id=6)

查询与一个节点同级的节点（族兄弟）。 如果在表中设置了级别的字段，那么在做这类查询时会很轻松，同一级别的就是与那个节点同级的，在这里列出不使用该字段时的实现!

with tmp as(
      select a.*, level leaf        
      from tb_menu a                
      start with a.parent is null     
      connect by a.parent = prior a.id)
select *                               
from tmp                             
where leaf = (select leaf from tmp where id = 50);

这里使用两个技巧，一个是使用了level来标识每个节点在表中的级别，还有就是使用with语法模拟出了一张带有级别的临时表。

查询一个节点的父节点的的兄弟节点（伯父与叔父）。

with tmp as(
    select tb_menu.*, level lev
    from tb_menu
    start with parent is null
    connect by parent = prior id)
    
select b.*
from tmp b,(select *
            from tmp
            where id = 21 and lev = 2) a
where b.lev = 1
 
union all
 
select *
from tmp
where parent = (select distinct x.id
                from tmp x, --祖父
                     tmp y, --父亲
                     (select *
                      from tmp
                      where id = 21 and lev > 2) z --儿子
                where y.id = z.parent and x.id = y.parent); 

这里查询分成以下几步。
首先，将第7个一样，将全表都使用临时表加上级别；
其次，根据级别来判断有几种类型，以上文中举的例子来说，有三种情况：
（1）当前节点为顶级节点，即查询出来的lev值为1，那么它没有上级节点，不予考虑。
（2）当前节点为2级节点，查询出来的lev值为2，那么就只要保证lev级别为1的就是其上级节点的兄弟节点。
（3）其它情况就是3以及以上级别，那么就要选查询出来其上级的上级节点（祖父），再来判断祖父的下级节点都是属于该节点的上级节点的兄弟节点。
最后，就是使用union将查询出来的结果进行结合起来，形成结果集。

查询一个节点的父节点的同级节点（族叔）。

这个其实跟第7种情况是相同的。

with tmp as(
      select a.*, level leaf        
      from tb_menu a                
      start with a.parent is null     
      connect by a.parent = prior a.id)
select *                               
from tmp                             
where leaf = (select leaf from tmp where id = 6) - 1;

基本上，常见的查询在里面了，不常见的也有部分了。其中，查询的内容都是节点的基本信息，都是数据表中的基本字段，但是在树查询中还有些特殊需求，是对查询数据进行了处理的，常见的包括列出树路径等。

补充一个概念，对于数据库来说，根节点并不一定是在数据库中设计的顶级节点，对于数据库来说，根节点就是start with开始的地方。

下面列出的是一些与树相关的特殊需求。

名称要列出名称全部路径。

这里常见的有两种情况，一种是从顶级列出，直到当前节点的名称（或者其它属性）；一种是从当前节点列出，直到顶级节点的名称（或其它属性）。举地址为例：国内的习惯是从省开始、到市、到县、到居委会的，而国外的习惯正好相反（老师说的，还没接过国外的邮件，谁能寄个瞅瞅 ）。
从顶部开始：

select sys_connect_by_path (title, '/')
from tb_menu
where id = 50
start with parent is null
connect by parent = prior id;

从当前节点开始：

select sys_connect_by_path (title, '/')
from tb_menu
start with id = 50
connect by prior parent = id;

在这里我又不得不放个牢骚了。oracle只提供了一个sys_connect_by_path函数，却忘了字符串的连接的顺序。在上面的例子中，第一个sql是从根节点开始遍历，而第二个sql是直接找到当前节点，从效率上来说已经是千差万别，更关键的是第一个sql只能选择一个节点，而第二个sql却是遍历出了一颗树来。再次ps一下。

sys_connect_by_path函数就是从start with开始的地方开始遍历，并记下其遍历到的节点，start with开始的地方被视为根节点，将遍历到的路径根据函数中的分隔符，组成一个新的字符串，这个功能还是很强大的。

列出当前节点的根节点

在前面说过，根节点就是start with开始的地方。

select connect_by_root title, tb_menu.*
from tb_menu
start with id = 50
connect by prior parent = id;

connect_by_root函数用来列的前面，记录的是当前节点的根节点的内容。

列出当前节点是否为叶子。

这个比较常见，尤其在动态目录中，在查出的内容是否还有下级节点时，这个函数是很适用的。

select connect_by_isleaf, tb_menu.*
from tb_menu
start with parent is null
connect by parent = prior id;

connect_by_isleaf函数用来判断当前节点是否包含下级节点，如果包含的话，说明不是叶子节点，这里返回0；反之，如果不包含下级节点，这里返回1。

至此，oracle树型查询基本上讲完了，以上的例子中的数据是使用到做过的项目中的数据，因为里面的内容可能不好理解，所以就全部用一些新的例子来进行阐述。以上所有sql都在本机上测试通过，也都能实现相应的功能，但是并不能保证是解决这类问题的最优方案（如第8条明显写成存储过程会更好）.

参考文章

七. 用jpa保存方法出错

Spring4+Spring4MVC+SpringData+JPA+Hibernate4项目出现了

HTTP Status 500 - Request processing failed; nested exception is org.springframework.dao.InvalidDataAccessApiUsageException: Executing an update/delete query; nested exception is javax.persistence.TransactionRequiredException: Executing an update/delete query

错误，解决方案
在@Modifying后面加@Transactional

八. Windows下Redis清除缓存

1. 找到Reids的安装目录，打开运行 redis-cli.exe

2. 输入 flushdb或者flushAll命令，执行即可

九. Oracle数据库实现分页

1. rownum简介

Oracle中通过rownum实现分页，rownum是一个伪列，在普通的查询中是不可见的，需要取出数据后rownum才会有值。
例如*我们需要查询员工表中的员工信息，并且显示出数据的序号。*

SELECT rownum AS 序号, ename AS 姓名, sal AS 工资

这里的rownum可以根据意思看成行号。

2. 实现分页

知道了rownum是什么，我们就很容易使用这个伪列来对查询的结果集进行分页。

查询工资从高到低的员工信息，以一页5条数据分页，查询出第二页

-- 第一步，查询出所有信息，并根据工资排序
SELECT sal, ename, FROM emp WHERE sal IS NOT NULL order by sal

-- 第二步，取得排序后的序号，过滤掉10行以后的数据

SELECT  rownum AS rn, sal, ename 
 FROM(
    SELECT sal, ename, FROM emp WHERE sal IS NOT NULL order by sal
 ) x 
 WHERE rownum <= 10

--第三步，在前10行数据中再过滤掉6行以前的数据
SELECT rn AS 序号, ename AS 姓名, sal AS 工资
FROM(
    SELECT rownum AS rn, sal, ename 
    FROM(
        SELECT sal, ename, FROM emp WHERE sal IS NOT NULL order by sal
    ) 
    WHERE rownum <= 10
)
WHERE rn >= 6

--另外一种写法
SELECT rn AS 序号, ename AS 姓名, sal AS 工资
FROM(
    SELECT rownum AS rn, sal, ename 
    FROM(
        SELECT sal, ename, FROM emp WHERE sal IS NOT NULL order by sal
    )
) a
WHERE a.rn between 6 and 10

在这里为什么不直接在第一步就取出rownum呢？因为如果第一步就取出rownum

SELECT rownum as rn, sal, ename, FROM emp WHERE sal IS NOT NULL order by sal

这条查询语句执行的顺序是：先取出数据（包括rownum），再排序。所以取出来的数据可能是这样的：

   rn     sal    ename
------- ------- ---------
      1    3000       TOM
      4    2888     JONES
     15    2560      FORD
     21    1300     ADAMS
      3     900     SIMTH

      ...

在第二步中取出rownum能保证rownum为排序后的rownum（1，2，3，4，…），而不是排序之前的rownum。

3. 与MySQL相比

与MySQL相比相对比较麻烦，MySQL中只要使用关键字limit就能指定数据的开始下标和条数。

--从第六条开始，取五条数据
SELECT * FROM emp limit(6,5);