JDBC是Java连接数据库的标准，为了兼容大部分数据库，Java提出了JDBC标准，通过这个标准，让各个数据库提供实现支持，这样实现一处编码，处处运行的Java特性。

习惯了ORM框架，却忘记了原本的JDBC，所以我觉得有必要复习来夯实一下基础。

前面简单介绍了Spring中AOP的使用，是基于XML配置。这次详细介绍一下Spring中AOP的使用和实现。

0x00 AOP是什么

AOP (Aspect Oriented Programming)面向切面编程，Spring是通过Java动态代理实现的。

AOP的目的是为了将组件和业务代码分离开，让日志、事务处理、缓存、性能统计、权限控制等等模块跟实际的业务模块解耦。

这么说还是很笼统，Java的类中，属性和方法才是主流，切面是什么，完全没这个概念。
那么以拍电影举个栗子：

1
2
3
4
5

1.前期筹备，剧本确定、演员试镜确定
############分割线a
2. 开拍、剪辑、制作
############分割线b
3. 营销、宣传、公映

1->2->3这个流程是拍电影的业务流程，但是如果我要拍花絮怎么办，这个流程不属于现在的电影业务流程，我们需要安排一个零时的业务，那我们就要在############分割线a分割线那里添加摄花絮的计划，分配一些人员。
那么分割线那里，就是切面。这些切面干什么，由切面代理去管理和运行，这就是AOP。

讲道理，全栈工程师很少说自己是全栈，倒是一些什么都会一点的人喜欢把全栈挂嘴边，其实什么都不精通。
一直想做个全栈，可惜还差得远。所以写个计划：一方面激励一下自己，防止放荡不羁的太过分；另一方做个积淀，是时候正儿八经的做事情了。

目前计划只是个雏形，不过肯定是围绕Java Web和NodeJS的
后面也许会学习一下PHP和Python，但是不敢打包票，毕竟1口吃不下N个胖子

计划列表

1. Java 8新特性和老知识细嚼慢咽
2. Spring家族
3. MySQL
4. ES6.0
5. NodeJS
6. TypeScript
7. Angular 2 等前端框架

……乍一看已经挖坑很深了，后面服务器运维的东西已经不敢提上日程了。如果顺利的话，大概得明年才能开启。
目前打算Java语言特性会作为穿插写一写，先从Spring开始扒起，和持久层一起看，主要是自己看的东西，笔记，也可能是转载。

如果努力的话，上半年能把Spring家族的坑，填个十之八九，接下来就是新的JavaScript、NodeJS和一些前端框架了
年底如果没完成，自打80大板

这些年，互联网爆炸式的发展，促生了无数程序员。
也促生了达内，黑马，极客学院等大量 IT培训机构。
短短数年间，科班出生的程序员和培训机构出生的程序员呈指数增长。
程序员的职业也不再是金饭碗。写了这么多代码，有些感触，所以写下来。

0x00关于语言

从汇编到C语言，再从VB到C++，后来Java 、js……,越来越多的语言被创造出来，渐渐的出现一个奇怪的现象，程序员语言鄙视链。其实所谓的鄙视链往往也就是因为各种语言的性能以及难易度造成的。
按照我现在的经验，往往越高级的语言，越容易阅读，可性能也比不过C语言这种中层语言。因为一系列的检查机制和代码编译造成了一些性能浪费。

1. 编写配置文件

0x00 Consumer

接受一个参数，不反回结果，所以是消费者

1
2
3
4
5
6

/**
  * Performs this operation on the given argument.
  *
  * @param t the input argument
  */
 void accept(T t);

内部还有一个默认方法

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

/**
  * 返回一个组合的Consumer，依次执行前面Consumer的`accept()`， 接着是{@code after}后操作。
  * 如果执行任一操作抛出异常，则将异常抛出给操作的调用方。
  * 如果执行前面的`accept()`会引发异常，则不执行{@code after}后的操作。
  *
  * @param after the operation to perform after this operation
  * @return a composed {@code Consumer} that performs in sequence this
  * operation followed by the {@code after} operation
  * @throws NullPointerException if {@code after} is null
  */
 default Consumer<T> andThen(Consumer<? super T> after) {
     Objects.requireNonNull(after);
     return (T t) -> { accept(t); after.accept(t); };
 }

搭建Java服务器就是把JavaEE的Web部署环境和软件都安装好，这是我自己用旧的PC搭建的，所以只是单个服务器，不涉及分布式。这些安装步骤都可以单独找教程

0x00 前言

• gcc gcc-c++
• JDK
• Redis
• Nginx
• MySQL
• NodeJS
• Jenkins

可能需要的附加软件

• git
• Python

• Python pip
  …

  阅读全文 »

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

0x00 先介绍卸载

防止重装

• yum方式

1
2

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

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

0x00 备份原来的源

1

$ sudo mv /etc/yum.repos.d/CentOS-Base.repo /etc/yum.repos.d/CentOS-Base.repo.bk

0x01 下载阿里源

1
2

$ cd /etc/yum.repos.d
$ sudo wget -nc http://mirrors.aliyun.com/repo/Centos-7.repo

0x02 更改阿里yum源为默认源

1

$ sudo mv CentOS-7.repo CentOS-Base.repo

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. 学习方式:
   
   完全可以自学，最好自己有电脑。

   阅读全文 »

前言

1.Tomcat的目录结构

改变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）
  阅读全文 »