人生中唯一的2016

2016-12-31

在人生中的每一天都是唯一的，转眼就到了今年的最后一天。在这最后一天里，不禁想问自己，你在这一年里收获了什么？在时间长河里为这个世界留下了什么？创造了什么价值？在这一年里有哪些遗憾？接下来的一年里你有什么打算？

收获的

拿到了驾照，从三月份报考，差不多半年，每周末练车，在十月份的时候驾照终于到手。
读完了：《皮囊》《动物庄园》《黄金时代》《白夜行》《嫌疑人X的献身》《解忧杂货铺》《精进》《巨流河》《HTTP权威指南》《Head First设计模式》，正在读《禅与摩托车维修艺术》
每天上班地铁背英语单词，坚持200多天，对英语有了一些感想
练字，硬笔楷书，100天出头。
500多个随手小视频，用视频记录下2016生活中的点滴。几十年后再来看这些视频，肯定会有一番不一样的感受。
看了一段时间关于编译原理的视频与资料，对编译原理有了一些了解

留下的

作为公司基础开发框架产品负责人，产品今年迭代了12个版本，越来越稳定，在稳定中不断的打磨脱变。通过该产品，提升了开发人员的开发效率。
博客开通，分享50多篇原创博客，希望能帮助到一些人。
stackoverflow从0到将近500分，算是常年在上面找到有用答案的反馈。

其它重要事件

年初跟媳妇儿以及爸妈全家人到云南自驾游一圈
买房，三十而立算是有了基础
老婆怀孕，明年等着升级，得多赚奶粉钱了

遗憾

书法练习未能连续坚持
系统架构师考试未能通过

2017

博客继续写下去
坚持练字
囤着还未看的书，希望能看掉一些：《算法》第四版、《TCP/IP》卷一、《经济学原理》-曼昆、《瓦尔登湖》、《英语语法实践指南》、《数学之美》
想要学习的领域：机器学习、推荐引擎
接受新的挑战

展开全文 >>

MySQL 5.7 绿色版安装

2016-12-29

安装环境为windows2008 R2，X64

一、下载解压

官网下载地址：http://dev.mysql.com/downloads/mysql/
选择跟环境对应的版本，然后解压即可。我这里解压到C:\work\mysql-5.7.17-winx64

二、环境变量配置

把C:\work\mysql-5.7.17-winx64\bin添加到用户的环境变量path中

三、添加配置文件

复制my-default.ini一份该文件，在当前目录下粘贴为my.ini，并增加如下内容

[client]
default-character-set=utf8
[mysqld]
character_set_server=utf8
basedir=C:\work\mysql-5.7.17-winx64
datadir=C:\work\mysql-5.7.17-winx64\data
port   = 3306

修改默认的字符编码为UTF-8 解决中文乱码问题。

四、数据库初始化

用管理员身份打开CMD，并执行如下命令：

mysqld --initialize --user=mysql --console

结尾部分为初始化的随机root密码，可以先从控制台上复制下来，下一步修改密码会使用

五、修改root密码

运行如下命令：

mysql -u root -p 之后会提示输入密码
set password for root@localhost = password('root');修改密码为root

六、创建新用户

运行如下命令：

CREATE USER 'admin'@'%' IDENTIFIED BY 'password';
GRANT ALL PRIVILEGES ON *.* TO 'admin'@'%';

注意admin'@'%中的百分号，这里使用百分号意味着允许任意远程客户端连接。root@localhost意味着只允许本地客户端连接。

官方文档：http://dev.mysql.com/doc/refman/5.7/en/adding-users.html

七、添加为系统服务

运行如下命令：

mysqld --install MySQL57
net start MySQL57

删除服务可运行sc delete MySQL57

展开全文 >>

设计模式总结

2016-12-28

看完《Head First设计模式》一书，本篇算是对设计模式做一个简单的总结。

一、为什么要使用设计模式

个人觉得，设计模式存在的价值既是为了解决实际的问题。在碰到实际问题，合适的场景使用设计模式会带来如下好处：

让代码结构更加清晰
使得代码易于维护
利于后期功能扩展
使用共同的术语方便技术人员相互交流

二、如何使用设计模式

对于如何使用设计模式，个人觉得没必要去记住书中的设计模式使用套路，一个是的确很难记，另外就是设计模式应当是在解决实际问题中自然而然生长出来的，而不是套出来的。但是，还是应当对设计模式有所了解，这样在解决问题时容易获得灵感。

三、感想

在看本书之前，只熟悉常见的几个设计模式。看完之后给我最大的感受就是，虽然很多模式不知道，但是在实际的工作当中已经使用了大量的设计模式，比如装饰者、观察者、策略等模式。
当在实际工作当中，遇到需要解决的问题时，自然而然就会去想程序该怎么设计比较合理。在思考整个代码结构如何才能更优的过程中，应当忘记设计模式的使用套路，专注与问题的本质上。当以最优的方式解决问题后，这个最优解其实就是一种模式。
最后，一切应当以解决问题为导向。切记为了使用设计模式而生搬硬套的使用设计模式。代码应在解决问题的基础上以简洁、优雅、易懂为好。

四、设计模式系列文章

展开全文 >>

解决正确配置Servlet async-supported参数报错问题

2016-12-28

一、描述

环境：

JDK 1.7
Servlet 3.0
tomcat 7

Servlet 3.0新增异步处理支持，配置servlet参数<async-supported>true</async-supported> ，或通过注解方式启用@WebServlet(urlPatterns = "/demo",asyncSupported = true) 。当正确配置后，发现照例报如下错误：

java.lang.IllegalStateException: A filter or servlet of the current chain does not support asynchronous operations.
	org.apache.catalina.connector.Request.startAsync(Request.java:1660)
	org.apache.catalina.connector.Request.startAsync(Request.java:1653)
	org.apache.catalina.connector.RequestFacade.startAsync(RequestFacade.java:1022)

二、解决办法

找了一圈，所有的解决办法都在说可能是参数配置未配置正确，或者是需要在server.xml上配置。最后，在StackOverflow上找到了如下答案

1	request.setAttribute("org.apache.catalina.ASYNC_SUPPORTED", true);

三、其它

Servlet 3.0 新特性详解：https://www.ibm.com/developerworks/cn/java/j-lo-servlet30/

展开全文 >>

设计模式系列之十三代理模式

2016-12-25

代理模式可以理解为通过一个中间者来访问数据，比如我们通过代理来访问互联网，通过代理商购买游戏点卡等。这些都属于代理模式的设计思想。

上图为代理模式的一般数据交互逻辑。在Java后台开发中，使用RMI调用远程数据既采用了代理模式。

在我的实际开发中，以个人开发经验，使用代理模式最主要是为了解决如下两个问题:

封装访问远程数据的具体实现逻辑。即客户端只需调用Proxy提供的方法即可，不关心数据从哪里取，本地or远程。

提供一个统一的口径实现过滤。

下面分享一个使用到代理模式设计思想的代码样例。需求是这样的，前后端分离，前端统一使用$.ajax来请求后端提供的RESTFULL服务。需要在框架层面做到系统级的异常处理，即开发人员不需再关心系统级的异常，只需要关注业务逻辑。
针对于该需求，明显是需要一个Proxy，通过一个Proxy来转发前后端的交互。或者说叫做数据请求过滤器的东西，来劫持所有的前端数据请求。最终的实现样例代码如下所示。

(function(){

    //ajax方法clone
    var _ajax = $.ajax;

    //这里相当于劫持了原生的$.ajax方法，通过劫持实现对请求的过滤，系统级异常的捕获
    $.ajax = function(param) {
        //ajax deferred promise 保持原有promise操作
        var promise;

        var _param = $.extend({}, {autoWrap : true}, param);

        //如果不需要默认的封装:autoWrap = false;
        if (!_param.autoWrap) {
            promise = _ajax(_param);
            //直接返回
            return promise;
        }

        //default ajax options
        var defaultOpts = {
            type: "POST",
            dataType: "json",
            cache: false,
            headers: {
                "CSRFToken" : getCSRFToken()
            }
        };
        //deep extend
        _param = $.extend(true, defaultOpts, _param);

        //add timestamp
        if (!_param.cache) {
            var _url = _param.url || "";
            var stamp = "T="+ new Date().getTime();
            (_url.indexOf("?") == -1) ?( _url += "?"+stamp):( _url += "&"+stamp);
            _param.url = _url;
        }

        if (_param.success) {
            _param.callback = _param.success;
            delete _param.success;
        }

        promise = _ajax($.extend({
            success:function(response){
                var code = response.status || response.code || "200";
                //如果是整形，转换为字符串
                typeof(code)=="number" && (code=code+"");
                //状态码控制
                switch(code){
                    case "200":
                        //数据转发
                        if (_param.callback) {
                             _param.callback(response);
                        }
                        break;
                    case "401":
                        //需要认证：登录超时或未登录.Session超时，弹出登陆框，登录成功后继续业务逻辑。
                        ReLogin(function(){
                            $.ajax(param);
                        });
                        break;
                    case "400":
                        alert("请求异常！");
                        break;
                    case "403":
                        alert("请求的资源未授权！");
                        break;
                    case "500":
                        alert("<code>500:</code>服务器端异常,请联系管理员.<br/>"+(response.msg || response.message));
                        break;
                    default :
                        alert("<code>"+code+":</code>服务器端异常,请联系管理员.<br/>"+(response.msg || response.message));
                }
            },
            error:function(XMLHttpRequest, textStatus, errorThrown){
                console.log("ajax error:" + textStatus);
            }
        }, _param));

        return promise;
    };
})();

上一篇：设计模式系列之十二状态模式

展开全文 >>

设计模式系列之十二状态模式

2016-12-24

举一个自动取款机的场景来说明状态模式的使用。去自动提款机取钱首先得有插卡的动作，最后还会有取卡的动作。对应两个状态，一个是无卡状态，另外一个是有卡状态。

一、代码实现

public class ATM {
	final static int NO_CARD 	= 0;
	final static int HAVE_CARD  = 1;
	//提款机初始状态为无卡
	int state = NO_CARD;

	//插卡
	public void insertCard(){
		if(state==NO_CARD){
			System.out.println("插入卡片");
			//设置状态为有卡状态
			setState(HAVE_CARD);
		}else if(state==HAVE_CARD){
			System.out.println("已插入银行卡");
		}
	}

	//取卡
	public void quitCard(){
		if(state==NO_CARD){
			System.out.println("你没有插入银行卡");
		}else if(state==HAVE_CARD){
			System.out.println("退出卡片");
			//设置状态为无卡状态
			setState(NO_CARD);
		}
	}

	public void setState(int state){
		this.state = state;
	}
}

从上面的代码可以预见到，如果再增加状态，那么对应的操作里面就需要增加一组if-else，越到后面代码将越来越难以维护。

二、使用状态模式改造

//状态接口
public interface State {
	//插入卡片
	public void insertCard();
	//取出卡片
	public void quitCard();
}

//无卡状态
public class NoCard implements State{
	NewATM atm;
	public NoCard(NewATM newATM){
		this.atm = newATM;
	}

	@Override
	public void insertCard() {
		System.out.println("插入卡片");
		atm.setState(NewATM.HAVE_CARD);
	}

	@Override
	public void quitCard() {
		System.out.println("你没有插入银行卡");
	}
}

//有卡状态
public class HaveCard implements State{
	NewATM atm;
	public HaveCard(NewATM newATM){
		this.atm = newATM;
	}

	@Override
	public void insertCard() {
		System.out.println("已插入银行卡");
	}

	@Override
	public void quitCard() {
		System.out.println("退出卡片");
		atm.setState(NewATM.NO_CARD);
	}
}

//使用状态模式改造后的业务代码
public class NewATM {
	static State  NO_CARD;
	static State HAVE_CARD;

	private State state = NO_CARD;

	public NewATM(){
		NO_CARD 	= new NoCard(this);
		HAVE_CARD 	= new HaveCard(this);
	}
	//插卡
	public void insertCard(){
		state.insertCard();
	}

	//取卡
	public void quitCard(){
		state.quitCard();
	}

	public void setState(State state){
		this.state = state;
	}
}

经过改造，彻底干掉了繁琐的if-else状态判断。当有业务变更，或是新状态加入时可灵活的调整代码。

系列文章：
设计模式系列之一单例模式
 设计模式系列之二策略模式
 设计模式系列之三观察者模式
 设计模式系列之四装饰者模式
 设计模式系列之五工厂模式
 设计模式系列之六命令模式
 设计模式系列之八外观模式
 设计模式系列之七适配器模式
 设计模式系列之九模板方法模式
 设计模式系列之十迭代器模式
 设计模式系列之十一组合模式

展开全文 >>

Maven私服Nexus3.x权限配置

2016-12-23

一、禁用匿名访问权限

二、角色创建

三、人员创建

四、代理配置

通过该配置可以使得两个Nexus服务器相关联。

1.配置地址

2.配置用户

展开全文 >>

设计模式系列之十一组合模式

2016-12-21

组合模式：允许将对象组合成树型结构来表现“整体/部分”层次结构。组合能让一致的方式处理个别对象以及对象组合。

接上一篇**设计模式系列之十迭代器模式**的业务逻辑，现在集团公司业务扩张，新增了湖南分公司，那么采用迭代器模式可以很方便的打印出湖南分公司的所有部门。

一、新需求实现

//湖南分公司
public class HNBranch {
	ArrayList<Dept> depts;

	public HNBranch(){
		depts = new ArrayList<Dept>();
		//添加部门
		depts.add(new Dept("湖南-财务部"));
		depts.add(new Dept("湖南-开发部"));
	}

	//这里不再使用自定义实现的Iterator接口，而是使用Java原生集合对象的Iterator
	public Iterator createrIterator(){
		return new HNBranchIterator(depts);
	}
}

//湖南分公司的部门迭代器
public class HNBranchIterator implements Iterator{
	ArrayList<Dept> depts;
	int position	= 0;
	public HNBranchIterator(ArrayList<Dept> depts){
		this.depts = depts;
	}
	@Override
	public boolean hasNext() {
		if(position>=depts.size() || depts.get(position)==null){
			return false;
		}else{
			return true;
		}
	}

	@Override
	public Object next() {
		Dept dept = depts.get(position);
		position  = position + 1;
		return dept;
	}

}

public class TestNew {

	public static void main(String[] args) {
		Iterator BJ = new BJBranch().createrIterator();
		Iterator SH = new SHBranch().createrIterator();
		Iterator HN = new HNBranch().createrIterator();

		printDeptName(BJ);
		printDeptName(SH);
		//打印新设立的湖南分公司的所有部门
		printDeptName(HN);
	}

	private static void printDeptName(Iterator iterator){
		while(iterator.hasNext()){
			Dept dept = (Dept) iterator.next();
			System.out.println(dept.getName());
		}
	}
}

依次类推，如果再设立其它省份的分公司一样的可以很快增加上去。但是，如果需要在湖南分公司下再设立下隶属于湖南分公司的长沙分公司呢？此时，整个结构变为一棵树型结构。

二、组合模式使用

可使用组合模式来表现“整体/部分”层次结构。

//不管是分子机构，还是分支机构下的部门对象都需要继承组件对象
public abstract class Component {
	//不管是父节点还是叶子节点都有该方法
	public abstract String getName();
	public abstract void print();

	//叶子节点可以没有该方法
	public void add(Component component) {
		throw new UnsupportedOperationException();
	}
}

//分支机构，即父节点
public class Branch extends Component{
	ArrayList<Component> components;
	private String name;

	public Branch(String name){
		this.name = name;
		components = new ArrayList<Component>();
	}

	public void add(Component component){
		components.add(component);
	}

	public String getName(){
		return this.name;
	}

	public void print(){
		System.out.println(getName());
		System.out.println("----------------------");
		//打印子节点，这里既可以是叶子节点也可以是父节点。通过这里实现了递归
		for(Component com:components){
			com.print();
		}
	}
}

//机构中的部门对象，即叶子节点
public class Dept extends Component{
	private String name;

	public Dept(String name){
		this.name= name;
	}

	public String getName(){
		return this.name;
	}

	public void print(){
		System.out.println(getName());
		System.out.println("----------------------");
	}
}

//测试代码
public class Test {
	public static void main(String[] args) {
		//下面的为同级
		Component BJBranch = new Branch("北京分公司");
		BJBranch.add(new Dept("北京-财务部"));
		Component SHBranch = new Branch("上海分公司");
		SHBranch.add(new Dept("上海-财务部"));
		Component HNBranch = new Branch("湖南分公司");
		HNBranch.add(new Dept("湖南-财务部"));
		//下面的为子级
		Component CS = new Branch("长沙子公司");
		CS.add(new Dept("长沙-财务部"));
		HNBranch.add(CS);

		Component root = new Branch("集团公司");
		root.add(BJBranch);
		root.add(SHBranch);
		root.add(HNBranch);
		//这里会递归遍历下去，直至所有节点遍历完毕
		root.print();
	}
}

从上面的代码中可以看出，核心在于父节点与叶子节点都属于Component，才能组合在一起，实现递归打印。

上一篇：设计模式系列之十迭代器模式
下一篇：设计模式系列之十二状态模式

展开全文 >>

Linux下搭建Maven私服Nexus3.X

2016-12-21

操作系统为中标麒麟6，安装的Nexus版本为nexus-3.2.0-01-unix.tar.gz

一、准备

从官网 https://www.sonatype.com/download-oss-sonatype 下载最新版本的资源
Nexus 3.x.x的JDK环境要求为1.8

二、安装配置

下载下来nexus-3.2.0-01-unix.tar.gz后，我使用SecureFX把资源上传到了/opt目录下。SecureFX是一个客户端工具，通过UI界面就能对Linux上的文件做操作。

接下来使用SecureCRT连接上Linux服务器，在命令行输入如下命令

# 切换到opt目录
$ cd /opt

# 解压tar文件
$ tar xvzf nexus-3.2.0-01-unix.tar.gz

# 先切换到bin目录
$ cd nexus-3.2.0-01/bin/
# 启动服务器，同时还有stop，restart
$ ./nexus start

默认端口为8081，此时可通过http://yourIp:8081访问Nexus服务器。默认用户名与密码为admin/admin123.

如果要修改默认端口，可以到安装目录下找到etc/nexus-default.properties，修改application-port项，然后restart即可。

如果要卸载，使用rm -rf nexus-3.2.0-01删除掉安装目录即可。-r为子目录一起删，f为不用一一提示。

三、其它

在安装完修改端口为8083后，在浏览器中输入地址发现无法访问。

首先在Linux服务器上查看8083端口是否启用，通过netstat -lnp命令即可。

确认端口已正在使用服务器没问题后，在客户端的CMD中通过telnet yourIp 8083,发现客户端无法连接。

最后排查防火墙，在防火墙中设置允许8083端口的HTTP访问解决问题。

展开全文 >>

设计模式系列之十迭代器模式

2016-12-20

迭代器模式：提供一种方法顺序访问一个聚合对象中的各个元素，而又不暴露其内部的表示。

有这样的一个需求。一家集团公司在北京和上海分别有一家子公司，每家公司内部有自己的部门，且自己提供了打印部门的方法。其中一个子公司以数组来保存部门列表，另外一个以ArrayList来保存。现在需要打印所有的部门。

一、原始实现

//部门对象
public class Dept {
	private String name;

	public Dept(String name){
		this.name= name;
	}

	public String getName(){
		return this.name;
	}
}

//北京分公司
public class BJBranch {
	ArrayList<Dept> depts;

	public BJBranch(){
		depts = new ArrayList<Dept>();
		//添加部门
		depts.add(new Dept("北京-财务部"));
		depts.add(new Dept("北京-研发部"));
		depts.add(new Dept("北京-开发部"));
	}

	public ArrayList<Dept> getDepts(){
		return depts;
	}
}

//上海分公司
public class SHBranch {
	Dept[] depts;

	public SHBranch(){
		depts = new Dept[3];
		//添加部门
		depts[0] = new Dept("上海-财务部");
		depts[1] = new Dept("上海-研发部");
		depts[2] = new Dept("上海-开发部");
	}

	public Dept[] getDepts(){
		return depts;
	}
}

public class TestOld {
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		BJBranch BJ 			= new BJBranch();
		ArrayList<Dept> BJDepts = BJ.getDepts();
		SHBranch SH 	= new SHBranch();
		Dept[] SHDepts 	= SH.getDepts();
		//遍历两家子公司的所有部门
		/** 由于类型不同，需要两次循环 **/
		for(int i=0;i<BJDepts.size();i++){
			System.out.println(BJDepts.get(i).getName());
		}
		for(int i=0;i<SHDepts.length;i++){
			System.out.println(SHDepts[0].getName());
		}
	}
}

从上面的代码中可以看出，由于两家子公司的实现方式不一样，造成循环遍历时自能使用对应的方式来遍历，造成相当大的不便。

二、使用迭代器模式来解决问题

//迭代器接口
public interface Iterator {
	boolean hasNext();
	Object next();
}

//北京分公司的部门迭代器
public class BJBranchIterator implements Iterator{
	ArrayList<Dept> depts;
	int position	= 0;
	public BJBranchIterator(ArrayList<Dept> depts){
		this.depts = depts;
	}
	@Override
	public boolean hasNext() {
		if(position>=depts.size() || depts.get(position)==null){
			return false;
		}else{
			return true;
		}
	}

	@Override
	public Object next() {
		Dept dept = depts.get(position);
		position  = position + 1;
		return dept;
	}

}

//改造后的北京分公司
public class BJBranch {
	ArrayList<Dept> depts;

	public BJBranch(){
		depts = new ArrayList<Dept>();
		//添加部门
		depts.add(new Dept("北京-财务部"));
		depts.add(new Dept("北京-研发部"));
		depts.add(new Dept("北京-开发部"));
	}

	/*public ArrayList<Dept> getDepts(){
		return depts;
	}*/

	//改造为返回Iterator对象，而不是ArrayList
	public Iterator createrIterator(){
		return new BJBranchIterator(depts);
	}
}

//上海分公司的部门迭代器
public class SHBranchIterator implements Iterator{
	Dept[] depts;
	int position	= 0;
	public SHBranchIterator(Dept[] depts){
		this.depts = depts;
	}
	@Override
	public boolean hasNext() {
		if(position>=depts.length|| depts[position]==null){
			return false;
		}else{
			return true;
		}
	}

	@Override
	public Object next() {
		Dept dept = depts[position];
		position  = position + 1;
		return dept;
	}

}

//改造后的上海分公司
public class SHBranch {
	Dept[] depts;

	public SHBranch(){
		depts = new Dept[3];
		//添加部门
		depts[0] = new Dept("上海-财务部");
		depts[1] = new Dept("上海-研发部");
		depts[2] = new Dept("上海-开发部");
	}

	/*public Dept[] getDepts(){
		return depts;
	}*/

	//改造为返回Iterator对象，而不是数组
	public Iterator createrIterator(){
		return new SHBranchIterator(depts);
	}
}

//使用迭代器模式后的代码实现
public class TestNew {

	public static void main(String[] args) {
		Iterator BJ = new BJBranch().createrIterator();
		Iterator SH = new SHBranch().createrIterator();

		printDeptName(BJ);
		printDeptName(SH);
	}

	private static void printDeptName(Iterator iterator){
		while(iterator.hasNext()){
			Dept dept = (Dept) iterator.next();
			System.out.println(dept.getName());
		}
	}
}

从改造后的代码中可以看出，使用迭代器模式改造后，成功的屏蔽了北京与上海分公司遍历的差异。

在Java中使用Iterator去遍历ArrayList应该大部分人都知道,实际上这个Iterator就是迭代器模式的实现。如果不使用迭代器模式，可以试想一下HasTable、HashSet、HashMap等类型，每一个都得按对应的方式去循环遍历，相当的不方便。

上一篇：设计模式系列之九模板方法模式
下一篇：设计模式系列之十一组合模式

展开全文 >>

收获的

留下的

其它重要事件

遗憾

2017

一、下载解压

二、 环境变量配置

三、 添加配置文件

四、数据库初始化

五、修改root密码

六、创建新用户

七、添加为系统服务

一、为什么要使用设计模式

二、如何使用设计模式

三、感想

四、设计模式系列文章

一、描述

二、解决办法

三、其它

一、代码实现

二、使用状态模式改造

一、禁用匿名访问权限

二、角色创建

三、人员创建

四、代理配置

1.配置地址

2.配置用户

一、新需求实现

二、组合模式使用

一、准备

二、安装配置

三、其它

一、原始实现

二、使用迭代器模式来解决问题

二、环境变量配置

三、添加配置文件