还挺麻烦的，老折腾了，CentOS 7 用MariaDB代替了MySQL，
yum源里也没有MySQL，只能去Mysql官网去找源，这次用的是rpm安装，
不过由于服务器在国外，我的小水管4kb/s 安装了十几个小时。

0x00 先介绍卸载

防止重装

• yum方式

1
2

 #查看yum是否安装过mysql
yum list installed mysql*

如或显示了列表，说明系统中有MySQL

0x00 血泪！一人装机到深夜

淘来一个120G的固态，打算装个CentOS7，玩玩服务器，万万没想到遇到了一个神奇的坑。整到大半夜都没搞定
都是因为百度来的东西大部分已经是二手货了，很多操作并不知道为什么。自己也是棵白菜。唉
朕要把这个坑记住，以后以此为鉴。

0x01 准备

• 硬件 你需要一个PC或笔记本电脑（Mac建议别装双系统了，蛋疼，还是虚拟机去吧）、一个8GB的U盘，如果还有一台可以做U盘引导的电脑更好，最好是Windows的系统

• 软件 CentOS 7 x86_64的ISO文件和老毛桃U盘装机软件最新版

ps:老毛桃会被windows误杀，装之前先关闭各种杀毒软件和电脑管家

0x02 第一步：准备制作U盘

• 第二步，创建Angular CLI项目

ps:有26%的人称 Angular 2 环境设置是一大入门门槛，有22%的人说环境设置太过复杂。Angular CLI的诞生，正是为了解决这个问题

如果你没有安装CLI，附上官网给你：https://cli.angular.io/

我上一篇文章介绍了函数式接口和Lambda表达式 ，以及Java解决所谓的闭包。http://azing.xyz/2016/12/22/lambda-and-Functional-Programming
这次深入一下。

0x00 函数式接口

前面讲了一下函数式接口，不过可能只是讲了个大概，大致讲了一下什么是函数式接口

• 函数式接口就是：一个interface，里面只有一个抽象方法，其他什么都没有。
• FunctionalInterface注解标注一个函数式接口，不能标注类，方法，枚举，属性这些。
• 如果接口被标注了@FunctionalInterface，这个类就必须符合函数式接口的规范
• 即使一个接口没有标注@FunctionalInterface，如果这个接口满足函数式接口规则，依旧被当作函数式接口。

这次我们来用代码来深入了解函数式接口

0x00 JS中的闭包以及Java中替代方法

在Java中，是不允许将一个方法作为参数传递给另一个函数，也不允许将一个方法作为值，返回给调用者，这就是所谓的不支持闭包。

但是JavaScript是可以这么玩的。比如：

1
2
3
4
5
6
7

getWebResource(function(result,error){
  if(error){
    doException();
  }else{
    analysisResult(result);
  }
});

我们看到直接向getWebResource方法中传递了一个function，这个function用来解析网络请求结果。

但是Java不能这样，那Java一般是怎么玩耍的呢？

0x00关于黑客

电影里的黑客估计都见过，一大票年轻的小朋友都希望成为一个黑客，做一个现代的大侠。可是一般人估计高数都学不好（Like me），跟别谈高级计算机编程了。黑客干的跟电影里面差太远，一旦接触编程，自然都是各种枯燥的脚本，各种枯燥的数字，代码，还有搭配硬件一起玩耍，很少热能坚持往下走到天黑，正是黑客行业枯燥、要求编程能力好、还要有天赋，导致修成正果的人很少。于是黑客成为了网络时代的武林高手，黑帽子更是黑客江湖里面的反派魔王。

代理模式是设计模式中的一种，是比较常用的。这种模式在面向切面编程中发挥了很大的作用。
直接说代理模式比较抽象，我们先从使用场景开始入手。

那么，举个栗子来说一下代理模式

比如，烧开水泡茶这个活动，这件事情前面需要洗茶壶，后面需要把茶杯洗好收起来。我们将烧开水这件事抽象起来与其他的事情剥离，来降低耦合。前后的事情交给代理增强来做。

JDK 里面的动态代理

JDK是自带动态代理的，我们今天就介绍一下JDK中自带的动态代理的使用。

通过代码，我们来看看具体的。

首先，我们创建一个人类

1
2
3
4
5
6
7

package com.zing.proxy_demo;
/**
 * Created by zing on 2016/12/1.
 */
public class Person {
    public String name = "Zing"; 
}

再创建一个工作接口，并实现这个接口

1
2
3
4
5
6
7

package com.zing.proxy_demo;
/**
 * Created by zing on 2016/12/1.
 */
public interface iWorkingSomething {
     void work(Person who);
}

1
2
3
4
5
6
7
8
9
10
11

package com.zing.proxy_demo;
/**
 * Created by zing on 2016/12/1.
 */
public class GuDuWork implements iWorkingSomething {
    @Override
    public void work(Person someOne) {
        System.out.println(someOne.name + "正在咕嘟咕嘟烧开水……\n一年之后终于烧好了\n");
    }
}

有人要问为什么不直接写Work，要加层接口，这是要问Java里的动态代理是面向接口的，必须这么玩。

从代码里能看出来，Zing要放到work方法中，来烧开水。
我们还需要：

• 在烧水泡茶之前洗洗水壶，准备柴火。
• 在喝完茶之后，把茶杯洗好收起来

这俩动作，我们放在织入Handler中，让织入Handler，帮我们把这两个方法织入到work方法里。

我们创建一个织入组件

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

package com.zing.proxy_demo;

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;

/**
 * Created by zing on 2016/12/1.
 */
public class WavingInvocationHandler implements InvocationHandler {

    //需要代理的目标对象
    private Object target;

    /**
     * 将目标对象存入，一定得是具体的对象，而不是class
     * @param target
     */
    public WavingInvocationHandler(Object target) {
        this.target = target;
    }

    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        //前置增强 
        System.out.println("洗水壶，准备茶叶，茶点\n");

        //生成织入类，作为代理
        Object obj = method.invoke(target,args);

        //后置增强
        System.out.println("喝完，洗茶杯，收拾……\n");
        
        //将包含织入方法的代理对象返回  
        return obj;
    }
}

这个组件用来织入并生成新对象，那如何使用呢，我们可以用一个JUnit来验证一下。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

@Test
public void testProxy() {
    //需要代理的目标对象
    GuDuWork guDuGudu = new GuDuWork();
    //将原来目标放进织入组件中
    WavingInvocationHandler handler = new WavingInvocationHandler(guDuGudu);
    //生成织入增强的代理对象
    iWorkingSomething somethingWork = (iWorkingSomething) Proxy.newProxyInstance(
            guDuGudu.getClass().getClassLoader(),
            guDuGudu.getClass().getInterfaces(),
            handler
    );
    //代理对象增强版测试
    somethingWork.work(new Person());
}

我们看到了整个流程涉及到了4个方面

• 目标对象 GuDuWork
• 织入类 WavingInvocationHandler
• 代理对象 Proxy.newProxyInstance()方法生成的对象
• 接口 iWorkingSomething
  整个流程就是iWorkingSomething的子类在执行work(Person who)方法的时候，会在执行前完成一些任务，执行之后，也会完成一些任务。而这些任务不会让iWorkingSomething的实现类去操心。
  这就是完整的代理模式使用的简单演示。

在业务中，代理模式的应用

很多人会觉得，要是在work方法里面直接加前置方法，和后置方法不是更简单吗？
在这个demo里确实会省略很多代码。

不过：

• 当你在写完一个完整的业务模块，需要测试并打印日志。你会发现你的业务模块了充满了日志代码，而这些代码跟主业务逻辑没有半毛钱关系。还会影响代码阅读。
• 还有当一些一部消息需要传递到其他模块的时候，你不会希望发送消息的代码（一堆判断，验证，分析逻辑）出现在你主业务模块里面，而是自动触发。

以上两个场景只是简单的描述了一下，你会发现面向切面编程就是为了解决这些跟主业务垂直逻辑无关，但是却很重要的业务。

可是我们能不能更简单的实现代理模式呢？
答案是：可以，用CGLib。那么我来简单介绍一下CGLib的代理模式。

用CGLib实现代理模式

CGLib是利用字节码技术来创建代理子类的，可以再字节码层直接拦截父类方法，并且可以织入增强方法。只需要

• 目标对象
• 织入类
• 代理类

这3个即可，话不多说，亮代码

1

//目标对象依旧是 GuDuWork.class

织入类CGLibProxy

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

package com.zing.proxy_demo;

import org.springframework.cglib.proxy.Enhancer;
import org.springframework.cglib.proxy.MethodInterceptor;
import org.springframework.cglib.proxy.MethodProxy;
import java.lang.reflect.Method;
/**
 * Created by zing on 2016/12/10.
 */
public class CGLibProxy implements MethodInterceptor {
    private Enhancer enhancer = new Enhancer();
    /**
     * 创建代理对象
     * @param proxiedClass
     * @return
     */
    public Object madeAnProxiedObject(Class proxiedClass) {
        enhancer.setSuperclass(proxiedClass);
        enhancer.setCallback(this);
        return enhancer.create();
    }
    /**
     * 对代理类的方法进行增强！
     * @param o
     * @param method
     * @param params
     * @param methodProxy
     * @return
     * @throws Throwable
     */
    @Override
    public Object intercept(Object o, Method method, Object[] params, MethodProxy methodProxy) throws Throwable {
        //前置增强
        System.out.println("Zing 要请大家喝茶，快去通知小伙伴\n");
        //执行方法
        Object result = methodProxy.invokeSuper(o, params);
        //后置增强
        System.out.println("终于喝完了，大家都走了，留下Zing一个人默默的刷杯子\n");
        return result;
    }
}

代理对象（使用）

1
2
3
4
5
6

@Test
public void testCGLibProxy() {
    CGLibProxy cgLibProxy = new CGLibProxy();
    GuDuWork workingSomething = (GuDuWork) cgLibProxy.madeAnProxiedObject(GuDuWork.class); 
   workingSomething.work(new Person());
}

以上就是CGLib实现代理模式的代码。

小结

代理模式是重要的设计模式之一，有了代理模式，后面，也就有了著名的面向切面编程，Aspect Oriented Programming(AOP)。是Spring AOP的基石。希望大家看完有所收获

感兴趣的可以再了解一下CGLib，因为深入到字节码，CGLib能干的事情非常多，是一个非常强的Java库。

我的博客 Zing ，欢迎点击，来踩

love & peace
FS全栈计划目录：https://micorochio.github.io/fs-plan/

本来就是想弄一个独立博客的，可是博客开了大半年了，依旧没要认真更新起来。
一方面找不到合适的图床（借口），另一方面拖延症在作怪（真正原因）

但是我在简书上缺少写了一些，由于简书图片不能外链，所以博客就跟简书无法同步。
我就懒的更新博客了。但是我还是倾向独立博客的，因为更适合装逼。
菜逼也是渴望变成大神的。所以我会陆续把我的东西拿到博客上来的。

F**k Lazy

另外这几天Android框架雏形也已经抄的差不多了。唉，我尽量会把框架完善好，以供日后使用用

确实不能再懒了。

想通过自学成为一个有良好计算机专业素养的Java程序员要读哪些书？

转自github： codefollower 的书单

我为Java续一秒

1. 前提条件:
   
   需要有高中毕业的水准

   (或者同等学历的也行，比如中专，我本人就是读中专然后再读自考大专的)。
   

2. 学习方式:
   
   完全可以自学，最好自己有电脑。

   阅读全文 »

改变Launchpad内图标排列的行数和列数

启动终端

• 改变行数量
  defaults write com.apple.dock springboard-rows -int X

• 改变列数量
  defaults write com.apple.dock springboard-columns -int X

• 使改变生效
  killall Dock

  将X换成数字

如果想恢复原样

1
2
3

defaults write com.apple.dock springboard-rows Default
defaults write com.apple.dock springboard-columns Default
killall Dock

• 提示：千万不要改太小了，一行最少放5个，否则改回来你得拖好多图标到某页上
  
  本人实践，13寸笔记本上，最佳是一页5行，每行9个（rows=5，columns=9）
  阅读全文 »