name:{name} job:{job} life:{life} .format(name='walterlife', job='JAVA Backend Engineer', life='work hard and have fun')

在 Spring 框架中，依赖注入机制(DI)多用于对象间的依赖，也称之为IOC(控制反转)
大致意思是：程序在运行的时候，由外部容器动态的将依赖对象注入到组件中，比如当Spring 容器启动时，spring开始进行容器初始化，创建并管理bean对象，以及销毁他。所以我们不需要自己编写代码来创建bean对象，可以直接从spring容器中获取，此时控制权就发生转移，由应用程序转移到外部容器，即控制反转。

主要实现方式有两种:

• setter 方法注入
• 构造函数注入

setter 方法注入

• 该方法目前在Spring中最为常用
• 例子

声明

本文翻译自: http://www.roytuts.com/core-java-interview-questions-and-answers/

1. java thread对象可以掉用start 方法两次吗

1. 不可以，当连续调用start方法时，会抛出一个异常 – java.lang.IllegalThreadStateException
2. 参考下面例子

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

package com.walterlife.blog;

public class ThreadInvokeStartTwice extends Thread {

    @Override
        public void run() {
            // TODO Auto-generated method stub
            System.out.print("Thread runing" + Thread.activeCount());
        }

    public static void main(String[] args) {
        ThreadInvokeStartTwice thread = new ThreadInvokeStartTwice();
        thread.start();
        thread.start();
    }
}
// output
    Thread runing2Exception in thread "main" java.lang.IllegalThreadStateException
    at java.lang.Thread.start(Unknown Source)
at com.walterlife.blog.ThreadInvokeStartTwice.main(ThreadInvokeStartTwice.java:14)

适配器模式是结构型模式中的一种，他经常用于将两个没有联系的接口进行适配，使之可以结合使用。其中联合不相关接口的对象就是成为适配器。

就拿现实生活中的手机充电器举例子，我们就可以把手机充电器当做适配器，因为一般的插座电源都是220V的，但是手机电池是3V的，手机充电器就在手机电源和一般插座之间充当适配器的作用。

现在我们就拿这个例子来使用java实现适配器模式。

首先，我们实现两个类，Volt 和 Socket 类

Volt.java

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

package com.walterlife.dp.AdapterDP;

import org.apache.log4j.Level;
import org.apache.log4j.Logger;

public class Volt {
    private int volts;
    static Logger logger = Logger.getLogger(Volt.class);

    public Volt(int v) {
        this.volts = v;
    } 
    
    public void setVolts(int v) {
        this.volts = v;
    } 

    public int getVolts() {
        return this.volts;
    } 
}

生成器模式是创造型模式的一种, 和工厂模式，抽象工厂莫斯类似。该模式是为了解决该类问题：当工厂模式或抽象工厂模式中的对象包含很对属性时

之所以出现该种模式，主要因为工厂模式和抽象工厂模式存在以下问题

1. 当创建的对象需要的参数很多时，客户端程序很难保证参数顺序的正确性
2. 参数中有些对于个别对象是并不是必须的，但是工厂模式中必须传入工厂中所有对象的属性，如果不是必须的，也需要传入null
3. 针对上述情况，获取我们可以针对不对的对象生成不同属性的setter 函数，当此时工厂中的对象的状态是不一致的

生成器模式就很好的解决了上述问题

针对每种对象的属性不一致的问题，生成器模式是这样解决的：在生成对象时，使用step-by-step的方式去设置需要对象的属性,最后再返回创建好的对象

还是以在工厂模式中的Computer类为例子

首先我们在 Computer 内部实现一个 ComputerBuilder 公有的静态内部类，将客户端参数全部到该内部类的属性中，类名最好是类名+Builder来命名

该内部类对外提供构造函数，一系列setter 函数，用来设置optional parameters,并且这些setter函数都返回 Builder类本身

在全部设置完参数后，再调用build 函数来返回创造好的对象，该函数一般可以调用生成对象的私有构造函数

抽象工厂模式是创造型模式的一种，他和工厂模式类似，可以看作是工厂的工厂

工厂模式中使用一堆 if-else结构来返回客户端要的子类实例。抽象工厂模式不是用if-else，而是使用不同子类的工厂代理来返回子类实例

下面例子对之前工厂模式进行适当的修改,增加生成PC的PCFactory, 生成Server的ServerFactory
,以及修改ComputerFactory

PCFactory.java

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

package com.walterlife.dp.FactoryDP;

public class PCFactory implements ComputerAbstractFactory {
    private String ram;
    private String hdd;
    private String cpu;

    public PCFactory(String ram, String hdd, String cpu) {
        this.ram = ram;
        this.hdd = hdd;
        this.cpu = cpu;
    }

    @Override
    public Computer createComputer() {
        return new PC(ram, hdd, cpu);
    }
}

ServerFactory.java

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

package com.walterlife.dp.FactoryDP;

public class ServerFactory implements ComputerAbstractFactory {
    private String ram;
    private String hdd;
    private String cpu;

    public ServerFactory(String ram, String hdd, String cpu) {
        this.ram = ram;
        this.hdd = hdd;
        this.cpu = cpu;
    }

    @Override
    public Computer createComputer() {
        return new Server(ram, hdd, cpu);
    }
}

工厂模式是创造型模式的一种，在java框架如Spring,struts2被广泛运用

该模式运用于：当程序中有一父类和一堆子类，子类的创建是根据输入的不同返回不同的子类
实例。此时只要实现一个工厂类负责不同子类的返回，代替客户端程序来返回实例。

下面例子使用Computer的类来说明工厂模式的实现机制

超类

Computer.java

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

package com.walterlife.dp.FactoryDP;

public abstract class Computer {
    public abstract String getRam();
    public abstract String getHdd();
    public abstract String getCpu();
    
    public String toString() {
        return "RAM: " + getRam() 
            + " HDD: " + getHdd()
            + " CPU: " + getCpu();
    } 
}

设计模式 Overview

目前在现代语言开发中，设计模式是非常流行的,因为通常一种设计模式可以解决一种常见的开发问题。

如果你使用设计模式，你可以获得以下好处:

1. 设计模式已经是由前人经验总结好的， 其解决方法是通过标准实践测试过的，因此这可以帮你节省很多时间
2. 设计模式是可复用的，这大大提升了软件的鲁棒性和可维护性
3. 同时设计模式是面向对象，通俗易懂的，这样可以任务交接团队间交流时省去很多时间

设计模式总体上可以分为3大类:

1. 创造型模式
2. 结构型模式
3. 行为型模式

单例模式，从定义上看起来很简单，但是在实现上是富有争议的, 他严格规定了对象实例化的个数,而且保证在运行期间，JVM只存在一个实例。

在实现上，程序必须提供接口去访问该唯一实例。在运用上，单例模式可以运用在 logging, driver objects, caching 和 thread pool

在其他模式的实现中，也运用了单例模式，比如抽象工厂模式，生成器模式，原型模式，门面模式等。在java标准库中，java.lang.Runtime, java.awt.Desktop也运用了单例模式。

下面介绍常用的单例实现方法，和其使用方法

首先，所有的实现方法必须遵循以下几个原则：

1. 私有构造函数，保证该类不能从其他类中进行实例化
2. 私有静态类实例，保证该类只有一份实例
3. 共有的静态函数，返回该类的唯一的实例变量，这也是唯一一个外界获取该类实力对象的方法

饿汉实现方式

该种实现方式中，类实例是当类加载时就创建了，这种方式也是最简单的，但是这个缺点，就是该实例并不是在使用的时候才创建
下面是该种方式的实现代码

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

package com.walterlife.designparttern;

public class Singleton {
    private static final Singleton instance = new Singleton();

    private Singleton() {
    } 

    public static Singleton getInstance() {
        return instance;
    } 
}

如果程序中你不使用什么资源，该种方式是一种好的选择。但是在大部分场景中，单例中都会包含资源了，比如database connections, file handler. etc.

说明

本文翻译自 http://www.programcreek.com/2009/02/the-interface-and-class-hierarchy-for-collections/

collection 与 collections的区别

• 首先collection 与 collections 是两个不同的概念。就如下图所示，collection 类是collection层级的根接口类，而collections 则是提供了一系列操作 一些 collection 类型的静态方法
  

collection 类的层级关系

下图阐述了collection 类的层级关系

说明

以下记录是平时工作中bash 相关使用的点滴记录，会持续更新

bash 中使用数组

1

sites=("www.a.com www.b.com www.c.com www.d.com" "www.e.cn www.f.cn")   
n_sites=${#sites[*]} #获取一维sites的数组长度   
for ((i=0;i<$n_sites;i++))
do   
    inner_sites=(${sites[$i]}) #将一维sites字符串赋值到数组   
    n_inner_sites=${#inner_sites[*]} #获取二维sites的数组长度   
    for ((j=0;j<$n_inner_sites;j++));   
    do       
        echo ${inner_sites[$j]} #回显site   
    done   
done