Posted on | Edited on | In

正文

什么是 Docker ?

Docker的思想来自于集装箱，集装箱解决了什么问题？在一艘大船上，可以把货物规整的摆放起来。并且各种各样的货物被集装箱标准化了，集装箱和集装箱之间不会互相影响。那么我就不需要专门运送水果的船和专门运送化学品的船了。只要这些货物在集装箱里封装的好好的，那我就可以用一艘大船把他们都运走。docker就是类似的理念。现在都流行云计算了，云计算就好比大货轮。docker就是集装箱。

  1. 不同的应用程序可能会有不同的应用环境，比如.net开发的网站和php开发的网站依赖的软件就不一样，如果把他们依赖的软件都安装在一个服务器上就要调试很久，而且很麻烦，还会造成一些冲突。比如IIS和Apache访问端口冲突。这个时候你就要隔离.net开发的网站和php开发的网站。常规来讲，我们可以在服务器上创建不同的虚拟机在不同的虚拟机上放置不同的应用，但是虚拟机开销比较高。docker可以实现虚拟机隔离应用环境的功能，并且开销比虚拟机小，小就意味着省钱了。
  2. 你开发软件的时候用的是Ubuntu，但是运维管理的都是centos，运维在把你的软件从开发环境转移到生产环境的时候就会遇到一些Ubuntu转centos的问题，比如：有个特殊版本的数据库，只有Ubuntu支持，centos不支持，在转移的过程当中运维就得想办法解决这样的问题。这时候要是有docker你就可以把开发环境直接封装转移给运维，运维直接部署你给他的docker就可以了。而且部署速度快。
  3. 在服务器负载方面，如果你单独开一个虚拟机，那么虚拟机会占用空闲内存的，docker部署的话，这些内存就会利用起来。总之docker就是集装箱原理。

    作者：刘允鹏
    链接：https://www.zhihu.com/question/28300645/answer/67707287
    来源：知乎
    著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。

参考资料

Posted on | Edited on | In

Alibaba Java Diagnostic Tool Arthas/Alibaba Java诊断利器Arthas

  • Arthas 用户文档：https://alibaba.github.io/arthas/
  • 简介：
    Arthas 是Alibaba开源的Java诊断工具，深受开发者喜爱。
    当你遇到以下类似问题而束手无策时，Arthas可以帮助你解决：
    这个类从哪个 jar 包加载的？为什么会报各种类相关的 Exception？
    我改的代码为什么没有执行到？难道是我没 commit？分支搞错了？
    遇到问题无法在线上 debug，难道只能通过加日志再重新发布吗？
    线上遇到某个用户的数据处理有问题，但线上同样无法 debug，线下无法重现！
    是否有一个全局视角来查看系统的运行状况？
    有什么办法可以监控到JVM的实时运行状态？
    Arthas采用命令行交互模式，同时提供丰富的 Tab 自动补全功能，进一步方便进行问题的定位和诊断。

Posted on | Edited on | In

直接看JdbcType类

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
//
// Source code recreated from a .class file by IntelliJ IDEA
// (powered by Fernflower decompiler)
//

package org.apache.ibatis.type;

import java.util.HashMap;
import java.util.Map;

public enum JdbcType {
    ARRAY(2003),
    BIT(-7),
    TINYINT(-6),
    SMALLINT(5),
    INTEGER(4),
    BIGINT(-5),
    FLOAT(6),
    REAL(7),
    DOUBLE(8),
    NUMERIC(2),
    DECIMAL(3),
    CHAR(1),
    VARCHAR(12),
    LONGVARCHAR(-1),
    DATE(91),
    TIME(92),
    TIMESTAMP(93),
    BINARY(-2),
    VARBINARY(-3),
    LONGVARBINARY(-4),
    NULL(0),
    OTHER(1111),
    BLOB(2004),
    CLOB(2005),
    BOOLEAN(16),
    CURSOR(-10),
    UNDEFINED(-2147482648),
    NVARCHAR(-9),
    NCHAR(-15),
    NCLOB(2011),
    STRUCT(2002);

    public final int TYPE_CODE;
    private static Map<Integer, JdbcType> codeLookup = new HashMap();

    private JdbcType(int code) {
        this.TYPE_CODE = code;
    }

    public static JdbcType forCode(int code) {
        return (JdbcType)codeLookup.get(code);
    }

    static {
        JdbcType[] arr$ = values();
        int len$ = arr$.length;

        for(int i$ = 0; i$ < len$; ++i$) {
            JdbcType type = arr$[i$];
            codeLookup.put(type.TYPE_CODE, type);
        }

    }
}

Posted on | Edited on | In

前言

设计模式，在我理解就是代码实践过程中，编码原则的一种提炼，用于应对各种复杂的项目场景。

使用模式最好的方式是：把模式装进脑子里，然后在你的设计和已有的应用中，寻找何处可以使用他们。
以往是代码复用，现在是经验复用。

正文

工厂模式

单例模式

Posted on | Edited on | In

前言

FindBugs解决方案。

参考

  1. 官网手册
  2. 用FindBugs分析代码漏洞

正文

EI: May expose internal representation by returning reference to mutable object

  • 官方描述

    Returning a reference to a mutable object value stored in one of the object’s fields exposes the internal representation of the object. If instances are accessed by untrusted code, and unchecked changes to the mutable object would compromise security or other important properties, you will need to do something different. Returning a new copy of the object is better approach in many situations.

  • 解决方案

EI2: May expose internal representation by incorporating reference to mutable object

  • 官方描述

    This code stores a reference to an externally mutable object into the internal representation of the object. If instances are accessed by untrusted code, and unchecked changes to the mutable object would compromise security or other important properties, you will need to do something different. Storing a copy of the object is better approach in many situations.

  • 解决方案

    解决方案

Field is a mutable collection

  • 官方描述

    A mutable collection instance is assigned to a final static field, thus can be changed by malicious code or by accident from another package. Consider wrapping this field into Collections.unmodifiableSet/List/Map/etc. to avoid this vulnerability.

  • 解决方案 
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    import java.util.Collections;
    import java.util.HashMap;
    import java.util.Map;

    ...

    public static final Map<String, Object> ENGIN_DATATYPE;
    static {
        Map<String, Object> aMap = new HashMap();
        aMap.put("Number", "NUMBER,FLOAT,DOUBLE,DECIMAL,BINARY_FLOAT,BINARY_DOUBLE");
        aMap.put("String", "STRING,VARCHAR,CHAR,NCHAR,VARCHAR2,NVARCHAR2");
        aMap.put("Date", "DATE");
        aMap.put("Boolean", "BOOLEAN");
        aMap.put("Integer", "INTEGER,TINYINT,SMALLINT,MEDIUMINT,INT");
        aMap.put("BigNumber", "BIGNUMBER,BIGINT");
        aMap.put("Binary", "BINARY");
        aMap.put("Timestamp", "TIMESTAMP,DATETIME");
        aMap.put("Internet Address", "INTERNET ADDRESS");
        ENGIN_DATATYPE = Collections.unmodifiableMap(aMap); // 创建不可变集合
    }

Posted on | Edited on | In

前言

珊珊来迟的保险意识。

品牌选择

  • 招商仁和
  • 平安保险

原则

  • 纯寿险：可以考虑附加减额定寿
  • 重疾、轻疾：爱倍至同时保障了这两种，不过是有返还的，估计是比纯消费型贵的？或者选择其他产品？或者去除返还？

    可以不要返还，来换取更高的保额？？？

  • 住院医疗： 报销医疗费用，负责保险，上面两种负责赔付！

文章介绍

推荐欢迎关注微信公众号：深蓝保（shenlanbao）
简书

个人觉得不错，把保险产品的利害剖析得很到位，同时也很简单易懂，适合小白。

Posted on | Edited on | In

禁止转载

前言

主要是为了备份日常工作或学习过程中，觉得有所感触的代码实现过程，便于后续重复使用。

正文

PLSQL

游标锁表、循环更新

1
2
3
4
5
6
CURSOR c2 IS  
   SELECT aac002 FROM IEA4 WHERE CIE578 = PI_CIE578 FOR UPDATE;  
...
FOR v2 IN c2 LOOP
 UPDATE IEA4 SET AAC002 = nvl(pkg_fun.f_sfzhm15to18(aac002), aac002) WHERE CURRENT OF c2;
END LOOP;

MYSQL

查看编码格式

  • 查看数据库编码格式

    1
    show variables like 'character_set_database';

  • 查看数据表的编码格式

    1
    show create table <表名>;

JAVA

同步&异步httpClient请求

- 实现

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
import org.apache.http.HttpEntity;
import org.apache.http.HttpResponse;
import org.apache.http.HttpStatus;
import org.apache.http.NameValuePair;
import org.apache.http.client.HttpClient;
import org.apache.http.client.entity.UrlEncodedFormEntity;
import org.apache.http.client.methods.CloseableHttpResponse;
import org.apache.http.client.methods.HttpGet;
import org.apache.http.client.methods.HttpPost;
import org.apache.http.concurrent.FutureCallback;
import org.apache.http.entity.StringEntity;
import org.apache.http.impl.client.CloseableHttpClient;
import org.apache.http.impl.client.DefaultHttpClient;
import org.apache.http.impl.client.HttpClients;
import org.apache.http.impl.nio.client.CloseableHttpAsyncClient;
import org.apache.http.impl.nio.client.HttpAsyncClients;
import org.apache.http.message.BasicNameValuePair;
import org.apache.http.util.EntityUtils;

import java.io.UnsupportedEncodingException;
import java.nio.charset.Charset;
import java.util.ArrayList;
import java.util.List;
import java.util.Map;

public class HttpClientUtil {

    /**
     * 发送POST   支持http、https
     *
     * @param url      post地址
     * @param paramMap 要传递的参数封装成Map
     */
    public static String sendPost(String url, Map<String, String> paramMap) {
        String returnmsg = "";
        try {
            //封装参数
            List<NameValuePair> parameters = new ArrayList<NameValuePair>();
            if (paramMap != null && paramMap.keySet() != null) {
                for (String key : paramMap.keySet()) {
                    parameters.add(new BasicNameValuePair(key, paramMap.get(key)));
                }
            }
            //创建UrlEncodedFormEntity对象
            UrlEncodedFormEntity formEntiry = new UrlEncodedFormEntity(parameters, "UTF-8");
            if (url.startsWith("https")) {
                //returnmsg=sendPostHttps(url,formEntiry);
            } else {
                returnmsg = sendPostHttp(url, formEntiry);
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
        return returnmsg;
    }

    //发送http请求
    public static String sendPostHttp(String url, UrlEncodedFormEntity formEntiry) {
        // 发送请求
        HttpClient client = new DefaultHttpClient();
        String returnmsg = "fail"; //失败
        try {
            //实例化HTTP POST方法
            HttpPost postmethod = new HttpPost(url);
            postmethod.setEntity(formEntiry);

            //执行请求
            HttpResponse reponse = client.execute(postmethod);
            //回去返回实体
            HttpEntity entity = reponse.getEntity();
            returnmsg = EntityUtils.toString(entity, "UTF-8");
            //System.out.println("POST返回数据:"+returnmsg);
            //若返回消息有中文要进行一下解码   服务器要加码URLEncoder.encode("服务器返回中文", "UTF-8")
            //System.out.println("POST返回数据--:"+URLDecoder.decode(returnmsg,"utf-8"));
        } catch (Exception e) {
            returnmsg = "fail";
            e.printStackTrace();
        } finally {
            //关闭连接,释放资源
            client.getConnectionManager().shutdown();
        }
        return returnmsg;
    }

    /**
     * application/json
     *
     * @param url
     * @param params
     * @return
     */
    public static String sendPostHttpJson(String url, String params) {
        HttpClient httpClient = null;
        HttpPost postMethod = null;
        HttpResponse response = null;
        String returnmsg = "fail"; //失败
        try {
            httpClient = HttpClients.createDefault();
            postMethod = new HttpPost(url);//传入URL地址
            postMethod.addHeader("Content-type", "application/json; charset=utf-8");
            postMethod.setEntity(new StringEntity(params, Charset.forName("UTF-8")));
            response = httpClient.execute(postMethod);//获取响应
            int statusCode = response.getStatusLine().getStatusCode();
            HttpEntity httpEntity = response.getEntity();
            String reponseContent = EntityUtils.toString(httpEntity);
            EntityUtils.consume(httpEntity);//释放资源
            if (statusCode == HttpStatus.SC_OK) {
                returnmsg = reponseContent;
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
        return returnmsg;
    }

    /**
     * 发送GET请求
     *
     * @param url
     * @return
     */
    public static String doGet(String url) {
        String reqUrl = url;
        CloseableHttpResponse response = null;
        CloseableHttpClient client = null;
        HttpGet httpGet = new HttpGet(reqUrl);
        String result = "fail"; //失败
        try {
            client = HttpClients.createDefault();
            response = client.execute(httpGet);
            int statusCode = response.getStatusLine().getStatusCode();
            HttpEntity httpEntity = response.getEntity();
            String reponseContent = EntityUtils.toString(httpEntity);
            EntityUtils.consume(httpEntity);//释放资源
            if (statusCode == HttpStatus.SC_OK) {
                result = reponseContent;
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
        return result;
    }

    /**
     * 发送异步POST请求
     *
     * @param url      post地址
     * @param paramMap 要传递的参数封装成Map
     */
    public static void sendAsyncPost(String url, Map<String, String> paramMap, FutureCallback callback) {
        //封装参数
        List<NameValuePair> parameters = new ArrayList<NameValuePair>();
        if (paramMap != null && paramMap.keySet() != null) {
            for (String key : paramMap.keySet()) {
                parameters.add(new BasicNameValuePair(key, paramMap.get(key)));
            }
        }

        CloseableHttpAsyncClient httpAsyncClient = HttpAsyncClients.createDefault();
        HttpPost httpPost = new HttpPost(url);
        try {
            UrlEncodedFormEntity formEntiry = new UrlEncodedFormEntity(parameters, "UTF-8");
            httpPost.setEntity(formEntiry);
            //start
            httpAsyncClient.start();
            //异步请求
            httpAsyncClient.execute(httpPost, callback);
        } catch (UnsupportedEncodingException e) {
            e.printStackTrace();
        }

        /*try {
            httpAsyncClient.close();
        } catch (IOException e) {
            e.printStackTrace();
        }*/
    }

    /**
     * 发送异步GET请求
     *
     * @param url post地址
     */
    public static void doAsyncGet(String url, FutureCallback callback) {
        CloseableHttpAsyncClient httpAsyncClient = HttpAsyncClients.createDefault();
        HttpGet httpGet = new HttpGet(url);
        //start
        httpAsyncClient.start();
        //异步请求
        httpAsyncClient.execute(httpGet, callback);

        /*try {
            httpAsyncClient.close();
        } catch (IOException e) {
            e.printStackTrace();
        }*/
    }
}

- 调用示例

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
/**
 * 调用示例
 */
Map<String, String> reqmap = new HashMap<>();
reqmap.put("basicPropertits", jobPropertyJson.toString());
reqmap.put("collectPropertits", jobConfigJson.toString());
reqmap.put("dataStore", jobStoreJson.toString());
reqmap.put("templatetList", jobProcJson.toString());

HttpClientUtil.sendAsyncPost(clctEngineMethodCollectTemplateUrl, reqmap, new launchServiceCallBack(id));

/**
 * http异步请求回调处理
 */
private class launchServiceCallBack implements FutureCallback<HttpResponse> {
    private int jobId = 0;

    launchServiceCallBack(int _iJobid) {
        this.jobId = _iJobid;
    }

    /**
     * 请求完成后调用该函数
     */
    @Override
    public void completed(HttpResponse httpResponse) {
        HttpEntity entity = httpResponse.getEntity();
        String rtnMsg = "{\"code\":\"fail\"}";
        String code = "fail";
        try {
            rtnMsg = EntityUtils.toString(entity, "UTF-8");
            Map<String, String> reqmap = (Map) JSONObject.fromObject(rtnMsg);
            code = reqmap.get("code").toString();

            if (code.equals(String.valueOf(HttpStatus.SC_OK))) {
                JobProperty load = jobPropertyService.load(this.jobId);
                load.setReleaseStatus(CollectionConstant.WHETHER_YES);
                load.setReleaseTime(new Date());
                jobPropertyService.update(load);
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    /**
     * 请求失败后调用该函数
     */
    @Override
    public void failed(Exception e) {
        System.out.println("failed");
    }

    /**
     * 请求取消后调用该函数
     */
    @Override
    public void cancelled() {
        System.out.println("cancelled");
    }
}

- 注意事项

  • 调用完成时，需及时关闭回收httpAsyncClient

Posted on | Edited on | In

牛客网

java专项练习

equals方法

【题目1】

有程序片段如下，以下表达式结果为 true 的是（B）
Float s=new Float(0.1f);
Float t=new Float(0.1f);
Double u=new Double(0.1);

A. s==t
B. s.equals(t)
C. u.equals(s)
D. t.equals(u)

答案解析

  • Float类和Double类都重写对于的equals方法，在比较之前都会判断是否同属于Float对象或Double对象，如果不是直接返回false，如果是再继续比较对应的数值大小。
  • 题目A比较的是两个对象的地址，显然不同的对象地址不同，A是false。B同属于Float对象且值相等，true。C和D比较的对象不同，false。
  • JDK1.8的源码如下：
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    >   // Float类重写了equals方法：
    >   public boolean equals(Object obj) {
    >   return (obj instanceof Float)
    >         && (floatToIntBits(((Float)obj).value) == floatToIntBits(value));
    >    }
    >   // Double类重写了equals方法：
    >   public boolean equals(Object obj) {
    >   return (obj instanceof Double)
    >         && (doubleToLongBits(((Double)obj).value) == doubleToLongBits(value));
    >   }
    >

Object类的描述

【题目1】

以下关于Object类的说法正确的是（B）
A. Java中所有的类都直接或间接继承自Object，无论是否明确的指明，无论其是否是抽象类。
B. Java中的接口(interface)也继承了Object类
C. 利用”==”比较两个对象时，Java调用继承自Object的equals方法，判断是否相等。
D. 如果类的定义中没有重新定义toString()方法，则该类创建的对象无法使用toStrig()方法。

答案解析

  1. 类Object是类层次结构的根类。每个类都使用Object作为超类。所有对象（包括数组）都实现这个类的方法。
  2. 接口和类是两个概念，但接口又和类具有一定的关系。类class是从java.lang.Object类派生而来，但接口interface并不是从某一个特定接口派生而来，两个interface可能没有任何交集，但两个class一定存在交集。接口不是Object的子类，但接口却隐士申明了Object中的所有可继承方法，类似于Object子类继承了它的所有可继承方法，区别只是这里申明的方法都是abstract形式，也即只有申明，没有方法体block。
  3. 对于指向对象类型的变量，如果要比较两个变量是否指向同一个对象，即判断这两个对象时（不是比较这两个对象的内容）这时候需要用==操作符进行比较。但equals方法是用于比较两个独立对象的内容是否相同
  4. 所有对象（包括数组）都实现object的方法，object里面有toString() 这个方法，所以即使类的定义中没有重新定义toString()方法，但是它同样可以使用toString这个方法（因为它继承了Object这个类）

集合

【题目1】

判断对错。List，Set，Map都继承自继承Collection接口。（A）
A. 错
B. 对

答案解析
png

Posted on | Edited on | In

原著阅读：掘金小册：程序员职业小白书 —- 如何规划和经营你的职业

职业规划

三个工具

  • 职业价值论
  • 职业象限和路线图
  • 职业画布

价值论

  • 你值多少钱？
  • 公司雇佣一个人，并不是看他有多牛，而是看他能给公司带来哪些价值；

市场需求

  • 专注细分市场：行业和技术的交叉，比如华资；
  • 专注新兴市场：比如互联网、大数据、人工智能；

信息透明度

  • 要做选择题，不要做判断题；
  • 求职渠道越多，信息就越透明；
  • 渠道优略：内推>拍卖>猎头>官网/招聘

四大象限

四大象限

雇员象限

  • 管理线 管理线
  • 专家线 专家线

SOHO象限

SOHO象限

创业象限&投资象限

创业象限&投资象限

技术岗位图

技术岗位图

职业画布

职业画布

简历

职业经营

程序员的本质

  • DRY: Don’t Repeat Yourself
  • WET: Write Everything Twice
    程序员的本质

技术方向和编程语言

  • Python：人工智能
  • JavaScript：前端和全端
  • Go：云计算和容器管理
  • PHP：网站的首选
  • Java：大数据分析

趋势

  • Web的富媒体化
  • 后移动互联网时代
  • 后端开发的平台化
  • AI First 时代已经到来