张爱强的博客/Eric Zhang's Blog

Spring 核心之IOC容器

2017-12-02T17:30:09+00:00

不得不说Spring框架非常强大而复杂；要想全面掌握Spring框架的方方面面需要大量的学习时间以及项目实践。而理解Spring核心原理是真正精通Spring必不可少的一环。利用本篇文章带领大家复习一下Spring的核心之一IOC容器，即控制反转或依赖注入。

Spring Framework

笔者最初接触Spring框架只是使用Spring framework作为bean的管理容器，使用Struts作为web MVC框架，使用JDBC原生Dao类访问数据库来开发Web项目。我想2012年以前参加工作的Java工程师应该都有类似的经验。而今天谈论Spring框架我们就应该说清楚讨论的是Spring core? Spring web Mvc? Spring cloud? Spring Data? Spring security? 还是Spring boot?

越来越多的分支项目被加入Spring框架，理解好Spring核心分支(Spring Framework)对于掌握好Spring其他项目的重要性不言而喻。下面这幅图来源于Spring.io官网，很好的展示了Spring Framework讨论的范畴，希望能将这幅图闹记于心。

Framework Modules（框架模块）

根据上图能够清晰的看到Spring Framework主要包含6个方面的内容：

核心容器(Core Container) – 核心中的核心
切面编程(AOP)
消息(Messaging)
数据访问(Data Access)
Web编程(MVC)
测试(Test)

本章主要讨论第一点内容核心容器(IOC)。

核心容器(Core Container)

相信所有工程师都知道Spring框架最原始最基本最核心的功能是帮助我们管理Bean，那么将Spring的核心称之为一个存储Bean的容器是不是不难理解？
所以，Spring的核心是一个容器，这个容器实现了控制反转(IoC)和依赖注入(DI)的特性，又称为IoC容器。

IoC容器如何创建Bean？

简单的回答就是IoC容器根据配置（XML或注解）来创建Bean，Bean在创建后被维护在Spring容器中随时可被使用，同时Spring容器负责维护Bean的生命周期。

复杂点讲，需要说明容器创建，维护，销毁Bean的机制性细节，如Bean生命周期, DI实现机制,集合值配置,集合值合并等。请参考阅读Spring IoC容器特性详解

这里说的配置包括纯XML,基于注解,基于Java的三种配置Spring方式，Spring并不强迫我们使用哪一种，甚至是支持混合使用这几种配置的。由于XML的说明性强于注解，所以官方大部分配置细节都采用XML结构讲解。

XML配置样例：

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xsi:schemaLocation="http://www.springframework.org/schema/beans
        http://www.springframework.org/schema/beans/spring-beans.xsd">

    <bean id="..." class="...">
        <!-- collaborators and configuration for this bean go here -->
    </bean>

    <bean id="..." class="...">
        <!-- collaborators and configuration for this bean go here -->
    </bean>

    <!-- more bean definitions go here -->

</beans>

如何编写XML配置

事实上本章不应该讨论这个话题，应为文章关注的是Spring Framework的核心机制，而非具体操作。值得提及的有几点内容：

结构化你的XML配置文件

<beans>
    <import resource="services.xml"/>
    <import resource="resources/messageSource.xml"/>
    <import resource="/resources/themeSource.xml"/>

    <bean id="bean1" class="..."/>
    <bean id="bean2" class="..."/>
</beans>

使用p-namespace

常规写法：

<bean id="myDataSource" class="org.apache.commons.dbcp.BasicDataSource" destroy-method="close">
    <!-- results in a setDriverClassName(String) call -->
    <property name="driverClassName" value="com.mysql.jdbc.Driver"/>
    <property name="url" value="jdbc:mysql://localhost:3306/mydb"/>
    <property name="username" value="root"/>
    <property name="password" value="masterkaoli"/>
</bean>

利用p-namespace简化xml结构，增强可读性。需要注意的是增加xmlns:p="http://www.springframework.org/schema/p 命名空间

<beans xmlns="http://www.springframework.org/schema/beans"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xmlns:p="http://www.springframework.org/schema/p"
    xsi:schemaLocation="http://www.springframework.org/schema/beans
    http://www.springframework.org/schema/beans/spring-beans.xsd">

    <bean id="myDataSource" class="org.apache.commons.dbcp.BasicDataSource"
        destroy-method="close"
        p:driverClassName="com.mysql.jdbc.Driver"
        p:url="jdbc:mysql://localhost:3306/mydb"
        p:username="root"
        p:password="masterkaoli"/>
</beans>

使用XMl Or 注解

随着Spring boot的出现，构建基于Spring的项目变得更为简单，大量注解被使用，不再看到xml的身影；甚至是配置文件也从properties变成了yml。

理解Spring容器上下文(Context)

每天一点小知识 String类

2017-12-01T16:21:09+00:00

String 类是java程序再常用不过的一个JDK级class，那么对于每天都要面对的String我们是否有足够的认识呢？今天希望通过一些小知识点让大家能够深入掌握String对象的日常处理。

String的存储结构

String类的每一个实例都使用一个数组（Array）最为底层存储数据结构。数组的类型为基本类型char，明白这一点之后我们应该意识到String类的绝大多数 API操作都是针对char数组的。例如indexOf,toUpperCase,toCharArray；这意味着很多操作会涉及到数组遍历。

substring源码解读

代码非常简单，主要看最后一行return (beginIndex == 0) ? this : new String(value, beginIndex, subLen); 如果截取下标从0开始则返回当前String对象，否则利用public String(char value[], int offset, int count)构造一个指定区间的新String对象。

public String substring(int beginIndex) {
        if (beginIndex < 0) {
            throw new StringIndexOutOfBoundsException(beginIndex);
        }
        int subLen = value.length - beginIndex;
        if (subLen < 0) {
            throw new StringIndexOutOfBoundsException(subLen);
        }
        return (beginIndex == 0) ? this : new String(value, beginIndex, subLen);
    }

indexOf源码解读

作为程序员通常只需要调用indexOf(“find”)就能得到结果，但实际执行的是下面这段代码；”find”是需要查找的对象作为target被传入，代码不是特别容易阅读，但是我们可以清晰的看到这种操作一定涉及数组遍历，所以如果能给定范围尽量使用多参调用来争取效率。

需要特别说明的是：不是一般程序员想象的直接去查找”find”，而是先找到”f”，再继续往下匹配。为什么这样？可以思考一下！

/**
     * Code shared by String and StringBuffer to do searches. The
     * source is the character array being searched, and the target
     * is the string being searched for.
     *
     * @param   source       the characters being searched.
     * @param   sourceOffset offset of the source string.
     * @param   sourceCount  count of the source string.
     * @param   target       the characters being searched for.
     * @param   targetOffset offset of the target string.
     * @param   targetCount  count of the target string.
     * @param   fromIndex    the index to begin searching from.
     */
    static int indexOf(char[] source, int sourceOffset, int sourceCount,
            char[] target, int targetOffset, int targetCount,
            int fromIndex) {
        if (fromIndex >= sourceCount) {
            return (targetCount == 0 ? sourceCount : -1);
        }
        if (fromIndex < 0) {
            fromIndex = 0;
        }
        if (targetCount == 0) {
            return fromIndex;
        }

        char first = target[targetOffset];
        int max = sourceOffset + (sourceCount - targetCount);

        for (int i = sourceOffset + fromIndex; i <= max; i++) {
            /* Look for first character. */
            if (source[i] != first) {
                while (++i <= max && source[i] != first);
            }

            /* Found first character, now look at the rest of v2 */
            if (i <= max) {
                int j = i + 1;
                int end = j + targetCount - 1;
                for (int k = targetOffset + 1; j < end && source[j]
                        == target[k]; j++, k++);

                if (j == end) {
                    /* Found whole string. */
                    return i - sourceOffset;
                }
            }
        }
        return -1;
    }

mvn package javax.crypto does not exist

2017-09-22T15:30:09+00:00

问题现象

有一次同事提交了代码Jenkins平台自动打包失败，而同事在本地是Eclipse开发环境使用mvn tomcat7:run 是可以成功运行项目的。
区别是Jenkins平台使用mvn clean package打包。错误说明是挺明显的package javax.crypto does not exist，但是在开发环境中没有任何问题，build path中包含了jre目录自然能够引用到jce.jar中的类。

[INFO] 49 errors
[INFO] -------------------------------------------------------------
[INFO] ------------------------------------------------------------------------
[INFO] Reactor Summary:
[INFO]
[INFO] services-consumer .......................... SUCCESS [  0.874 s]
[INFO] services-consumer-rest ..................... FAILURE [  2.240 s]
[INFO] job-consumer ............................... SKIPPED
[INFO] ------------------------------------------------------------------------
[INFO] BUILD FAILURE
[INFO] ------------------------------------------------------------------------
[INFO] Total time: 34.749 s
[INFO] Finished at: 2017-09-22T15:39:10+08:00
[INFO] Final Memory: 127M/430M
[INFO] ------------------------------------------------------------------------
[ERROR] Failed to execute goal org.apache.maven.plugins:maven-compiler-plugin:2.3.2:compile (default-compile) on project services-consumer-rest: Compilation failure: Compilation failure:
[ERROR] /Users/ervices-consumer-rest/src/main/java/com/test/portal/utils/RSAUtils.java:[18,19] error: package javax.crypto does not exist
[ERROR] /Users/services/services-consumer-rest/src/main/java/com/test/portal/utils/DesUtil.java:[11,19] error: package javax.crypto does not exist

报错的RSAUtils.java文件内容，包引用部分

import javax.crypto.BadPaddingException;
import javax.crypto.Cipher;
import javax.crypto.IllegalBlockSizeException;
import javax.crypto.NoSuchPaddingException;
import javax.crypto.SecretKey;
import javax.crypto.SecretKeyFactory;
import javax.crypto.spec.DESKeySpec;
import javax.crypto.spec.IvParameterSpec;

问题分析

怀疑Jenkins平台问题为了验证这个怀疑，我同步了最新的代码在本地使用mvn clean package 得到同样的错误信息，证明这个怀疑不成立。
Maven编译环境JDK问题既然IDE开发环境中编译时没有问题的，而使用mvn compile package install 都报错很容易联想到mvn的运行时环境中没有引用到jce.jar。

那么问题就变成了Maven是如何指定编译环境的？

请参见官方文档 http://maven.apache.org/plugins/maven-compiler-plugin/index.html

解决方法

maven 是通过插件来管理编译的，所以在pom.xml的maven-compiler-plugin可以设定编译器的lib包路径，添加上${java.home}/lib/jce.jar

<build>
  <plugins>
    <plugin>
      <groupId>org.apache.maven.plugins</groupId>  
      <artifactId>maven-compiler-plugin</artifactId>  
      <version>${maven_compiler_plugin_version}</version>  
      <configuration>
        <source>1.7</source>  
        <target>1.7</target>  
        <compilerArguments>
          <bootclasspath>${java.home}/lib/rt.jar:${java.home}/lib/jce.jar</bootclasspath>
        </compilerArguments>
      </configuration>
    </plugin>
  </plugins>
</build>

为什么需要使用微服务架构

2017-08-20T22:30:09+00:00

有时候我们需要回答这样一个问题，为什么选择使用某一种技术，放弃另一项技术？是因为它更贴合我们的业务，还是因为他已经是一种流行，一种趋势，还是另有原因？

什么是微服务

为什么出现微服务概念

以前为什么没提微服务

与SOA有什么不一样

微服务的支撑技术

一个真实的微服务项目概况

Oracle数据库删除重复数据

2017-08-04T09:30:09+00:00

由于越来越多的应用不采用数据库层的数据完整性约束（主要指外键约束和唯一性约束），那么也就会有越来越多的脏数据存在。

场景

假设：有如下A表（文章表）id为数据库主键，doc_id为业务上的主键用来确定唯一一篇文章

id	doc_id	doc_name	doc_link	doc_author	update_time
1	A000001	架构技术演进	test.com/a000001.html	张三	2016-03-04
2	A000001	架构技术演进	test.com/a000001.html	张三	2016-03-05
3	B000002	为什么使用微服务	test.com/b000002.html	李四	2017-01-01
4	B000003	分布式架构	test.com/b000003.html	王五	2017-03-01

假设：有如下B表（我阅读的文章表）id为数据库主键，read_doc_id业务上确定读了哪一篇文章，read_update_time 为最后一次阅读时间

id	user_id	read_doc_id	read_update_time
1	11101	A000001	2017-07-01

查询语句

select
  a.doc_name,
  a.doc_link,
  a.doc_author
  b.read_update_time
from a, b
where
  a.doc_id = b.read_doc_id and b.user_id = '11101'

页面结果

问题来了出现了重复的数据，原因是A表数据重复

如何定义重复

这依赖于我们面对的业务

业务主键重复
这种情况是指如A表中doc_id一旦重复，无论其他列是否重复都定义为重复
数值一致重复
想象一下A表没有id列并且其他列的值都一样

如何确定要删的行

通过count和having来看有哪些行是重复的

select a.doc_id, count(1) from a group by a.doc_id having count(1) > 1

得到下面的结果

doc_id	count(1)
A000001	2
B000002	1
B000003	1

重点是怎么删

1.业务主键重复
需要挑出一条来删，比如保留id主键最大的，或者保留update_time最近的，这完全取决你的实际情况。
删除重复数据的思想是利用业务主键确定要删除的数据集合，保留集合中最后一条数据即可

  create or replace procedure REMOVE_DUPLICATE_DATA is
    i NUMBER; -- 循环标记变量
  begin

    --根据业务主键循环所有重复数据
    for temp in (select a.doc_id, count(1) as c
                   from a
                  group by a.doc_id
                 having count(1) > 1) loop
      i := 0;
      --利用定位到的重复数据查到所有等待被删除的实际主键
      for tempx in (select id
                      from a
                     where a.doc_id = temp.doc_id
                     order by procinst_id) loop
      --需要保留一个不删除
        if (i < temp.c - 1) then
          --依次删除
          delete from a where id = tempx.id;
          i := i + 1;
        end if;
      end loop;
    end loop;
    commit;
  end;

2.数值一致重复
随便删哪一条，需要使用rownum
思想和第一种情况一样，但是没有主键的数值类重复找不到删除的唯一性条件所以需要加个rownum即可。

最佳实践

第一条. 数据主表该加唯一性约束的要加上
第二条. 没把握的insert()改成saveOrUpdate()

警惕你身边的架构师

2017-04-02T11:30:09+00:00

注意一点：在IT技术的世界里永远没有完美的方案，每一种技术都有他的强项和弱项。架构师很多时候在各种技术之间做出选择，而选择的依据就是哪一项技术更符合我们的业务，哪一项技术能够带来真正的价值。

如果你无法同意这个观点也就没必要继续往下阅读

什么是架构师

Architect 一词的本意是指建筑行业的设计师，用行业内的话说他们做的是结构设计，空间设计而不仅仅是我们一般人认为的美观性方面设计。

第一个问题是，这一类Architect需不需要在工地码砖？
答案是不需要的
第二个问题是，什么是软件行业的架构师？
没有人给这一类架构师做明确的定义，大多还是强调软件设计能力，关键技术突破能力和培养团队的能力。
我想说架构师并不是一种炫酷的Title，也不是管理者。他始终应该是一个工程师，追求卓越。比我们想象的高级更高级，是技术的广度与深度以及职业素养等等多方面的体现。

架构师的组织架构

我只能说一说自己经历的一些公司组织情况，欢迎网友通过留言来聊一聊架构师的其他组织形态。上图描述的是超大型集团企业的配置，这种类型的企业IT系统建设非常复杂。通常由于体制的复杂性和业务的复杂性共同导致的，同时架构师组织配置带来的价值也不容易衡量。个人认为这种配置在积极影响和消极影响两者当中消极影响通常会更突出。

CIO/CTO
我没有直接接触过CIO/CTO，对他们的工作内容和职责也无法轻率的做出评价。但我认为这个职位仍然是一个技术条线管理者，管理的重点是技术绝不是其他诸如人事、成本、利润、行政的东西。他们是一个公司技术发展的灯塔、布道师，他们的决策直接影响这团队的技术能力发展路线，以及最终是否能够实现技术变现。
架构委员会
就

积极影响

消极影响

架构师类型

编程型架构师
文档型架构师

总结

分布式框架Dubbox一

2017-03-02T23:30:09+00:00

Init

深入理解Java多线程二（Java线程的默认值）

2017-03-02T22:30:09+00:00

我想通过上一篇文章不可能让你彻底全面掌握OS层面的多线程技术，但是我们需要对以下内容有一定认识：

线程是进程中的一个控制点而已
线程是在CPU核的硬件线程上被运行的
每个线程有自己的内存堆栈

开始进入Java多线程技术的学习吧！！

Java Thread类源码

阅读源码

public class Thread implements Runnable {
    /* Make sure registerNatives is the first thing <clinit> does. */
    private static native void registerNatives();
    static {
        registerNatives();
    }

    private volatile String name;
    private int            priority;
    /* Whether or not the thread is a daemon thread. */
    private boolean     daemon = false;
    /* What will be run. */
    private Runnable target;


    /**
     * The minimum priority that a thread can have.
     */
    public final static int MIN_PRIORITY = 1;

   /**
     * The default priority that is assigned to a thread.
     */
    public final static int NORM_PRIORITY = 5;

    /**
     * The maximum priority that a thread can have.
     */
    public final static int MAX_PRIORITY = 10;

几个小问题

深入学习

创建自己的Thread

深入理解Java多线程一(认识线程)

2017-03-01T23:30:09+00:00

个人不认为在深入理解OS层面的线程，进程，I/O，内存等技术之前你能够真的掌握好面向某门特定语言的多线程技术。

因为特定语言环境下的线程只是一个线程对象，比如在Java中继承Thread类或实现Runnable接口就可以有我们自己的线程对象。但是，大家可以检查一下线程的状态，你会发现并没有Running状态。这是因为线程最终是靠OS调度系统来交给CPU的硬件线程运行的，不是JVM更不是我们写的业务代码。所以，这里希望掌握一个概念[硬件线程]。

伪多线程

在了解硬件线程这个概念之后，我们还需要明白他是属于CPU核(core)的，一个核就有对应一个硬件线程。所以我们在购买计算机的时候为什么要关注这个CPU是几核的？没错，核数越多说明CPU在同一时钟周期内能执行的线程就越多，简单点就是越快。

伪多线程是在核（core）上发生的，既然线程是受OS调度系统控制的，那么OS就有机会在这个过程中做点“手脚”。OS利用时间片（Time slice）技术实现伪多线程，让线程误以为CPU是给他一个人用的，事实上是一个硬件线程被足够小的时间片分割开交替执行多个线程指令，从而实现了伪多线程。