打着吊瓶写代码-CSDN博客

原创 AOP实现之代理bean创建过程(三)

上篇文章中已经讲解完毕spring是怎样来解析我们xml中的aop配置，同时也讲到了在解析过程中，它将会为我们创建几个必要的bean对像，接下来我们就讲解spring是如何来创建我们的代理对象的；在讲IOC的实现原理时，我们就说过，只有我们在第一次使用某个bean的时候，beanFactory才会为我们来创建bean对象(除非设置了lazy-init为false)，代理bean的创建和

2017-04-26 16:31:58 1192

原创 AOP实现之配置文件解析过程(二)

还记得我们在解析IOC时说过的一段代码吗？相关连接在这里 IOC实现之XML元素解析过程(三) ，这段代码位于DefaultBeanDefinitionDocumentReader类中，当时我们是这样说的：protected void parseBeanDefinitions(Element root, BeanDefinitionParserDelegate delegate) {

2017-04-23 20:33:36 1118

原创 AOP实现之相关概念与准备工作(一)

在讲AOP的实现原理之前，我们有必要先来了解一下什么是Aop，这里我不会说它的众多概念，如果想了解术语概念可以去看其它的文章；在网上或者各大书籍中都有关于AOP中各种概念的解释，比如通知，切面，连接点，切入点，目标类，代理，引入，织入等等概念，我个人觉得没有必要来专研这些学术概念的具体意思，简单的讲，不就是通过一些手段，在调用我们想要调用的方法前后自动的去调用另外的方法么！

2017-04-18 21:55:28 807

原创进阶篇:使用信号量Semaphore实现数据库连接池(十七)

我们先来看一下Semaphore 的定义；Semaphore：一个计数信号量。从概念上讲，信号量维护了一个许可集。如有必要，在许可可用前会阻塞每一个 acquire()，然后再获取该许可。每个 release() 添加一个许可，从而可能释放一个正在阻塞的获取者。但是，不使用实际的许可对象，Semaphore 只对可用许可的号码进行计数，并采取相应的行动。Semaphore 通常

2017-04-16 08:59:49 2053 1

原创进阶篇:定时任务执行之ScheduledThreadPoolExecuter(十六)

定时任务这个恐怕很多时候我们都需要用到吧...比如我们想间隔一天后执行某个定义好的任务，又或者间隔一天后执行完某个任务后，再每间1小时执行一次...当我们有这种需求的时候，ScheduledThreadPoolExecuter就派上用场啦！（注意，真正编程中，又大堆开源框架可以更好的帮你完成定时任务这个需求）ScheduledThreadPoolExecuter用法比较简单就不多说

2017-04-13 22:54:18 4328

原创进阶篇:优先级队列之PriorityBlockingQueue(十五)

今天我们来讲下PriorityBlockingQueue这个队列，它是一个优先级队列，什么是优先级呢？意思就是我们可以定义队列中哪个元素可以先被取出！它与前面介绍的LinkedBlockingQueue不同的地方就是，它是可以定义优先级的！且入队的元素必须实现Comparable接口！//优先级任务class PriorityTask implements Runnabl

2017-04-13 22:43:29 3783

原创进阶篇:延时队列之DelayQueue(十四)

这篇文章我们来讲讲BlockingQueue阻塞队列的另一个实现DelayQueue，先前我们的文章中有介绍LinkedBlockingQueue，而DelayQueue与之不同的是，DelayQueue里面哪怕有元素也无法取出，除非元素已经到期，而LinkedBlockingQueue只要里面有元素就可以取出！所以，你可以往DelayQueue中存放一个元素，且声明在半小时后才失效。

2017-04-13 22:18:27 821

原创进阶篇:线程并行与等待之CyclicBarrier(十三)

考虑这样一个场景，假设你有多个线程，这些线程并行执行，你设置了一个目的地，你想做到的是，无论哪个线程先到达目的地，都得等待其它线程到达，当指定数量的线程都到达目的地时，才允许它们继续一起往下执行；这个时候就是CyclicBarrier的用武之地了！ //一组任务并行执行，这些任务之间互相等待，直到指定的线程数都到达某一个屏障点(就是调用await的地方) ，才允许往下执行 //就

2017-04-13 21:56:39 791

原创进阶篇:等待多个子线程完毕再执行主线程的方法之CountDownLatch(十二)

想一想，有一天你想测试某个方法的性能，你可能会这么去做，你先开启多个线程，然后记录下多个线程的执行总时间，当多个线程全部执行完毕时，回到主线程将时间打印出来...问题在于，你怎么来控制主线程要在全部子线程执行完毕之后再执行呢？你可能会想到变量计数...主线程等待轮询... Ok，不兜圈子了，JDK的CountDownLatch类简直就是为解决这种问题而生的，我们先来看一下java的API

2017-04-12 22:30:35 1608

原创进阶篇:同步阻塞队列之LinkedBlockingQueue(十一)

JDK为我们提供了多个阻塞队列的实现，什么是阻塞队列呢？我们都知道队列就是一组数据的集合，而阻塞队列的意思是，当你往队列中取数据时，如果没有数据，你将被阻塞，一直等到拿到数据为止；今天我们就来看一下比较常用的遵循先进先出的阻塞队列LinkedBlockingQueue；//同步阻塞队列 //可以看到，当调用take()方法去拿数据时，如果里面没有数据，将造成阻塞 public sta

2017-04-12 22:10:34 1808

原创基础篇:线程间的协作之生产者与消费者(十)

生产者与消费者的代码实现，这个套路基本上和上篇文章一个样，所以我就不对代码多做解释了；之所以写这篇文章是为了介绍ReentrantLock 以及方便后面的一篇采用JDK提供的队列来实现生产者与消费者的代码来与之做比较；先看输出*******************************************************************************

2017-04-12 21:49:25 614

原创基础篇:线程间的协作之积累能量---放大招(九)

这篇文章我们来写一个小例子，充分利用notifyAll与wait等方法，来完成一个模拟游戏中不停的 “积累能量---放大招” 的例子！我们先看运行结果，再看代码:***********************************************************************************************开始第1次积累能量第1次积累能量

2017-04-12 21:22:15 675

原创基础篇:wait与notify与notifyAll(八)

这篇文章主要讲解多线程编程中 wait与notify与notifyAll 这三个方法的运用，了解了它们的基本用法后，我们再写个 “积累能量---放大招” 的例子来整合演示这几个方法的协作运用；见名之意，wait是等待的意思，当在线程A内调用wait()时，线程A将暂停运行，直到其它的线程通过调用notify或者notifyAll方法唤醒它为止；这三个方法都是从Object类继

2017-04-09 19:19:23 745

原创基础篇:让线程停止运行的几种方式(七)

这篇文章我们来讨论一下终止线程运行的方法；中断线程的方法： public static void stopThread() throws InterruptedException{ Thread t = new Thread(new Runnable() { @Override public void run() { while(!Thread.currentThr

2017-04-09 17:44:50 11960

原创基础篇:资源拷贝之ThreadLocal(六)

如果你有这样的需求，在不同的线程中对某个对象的修改不会影响到其它线程中该对象的状态，那么使用ThreadLocal将是非常不错的解决方案，事实上，这种需求是很常见的；我们来演示一下ThreadLocal的工作机制：//测试线程本地存储,证明对象复制与多个线程对ThreadLocal变量的修改互不影响 private static void testLocalThread() throws

2017-04-09 17:14:13 1214

原创基础篇:同步机制之synchronized与ReentrantLock(五)

我们继续来探讨同步机制的话题；上一篇文章说到了使用ReentrantLock的lock()来获取锁，但有时候我们可能有这样的需求，我们先尝试着去获取锁，但等了几秒实在拿不到锁就放弃获取锁而转做其它的事情，这个需求是很常见的，所幸的是，ReentrantLock提供了tryLock方法来帮助我们达到这样的目的；//演示锁的tryLock方法 public static void test

2017-04-09 16:53:57 614

原创基础篇:同步机制之synchronized与ReentrantLock(四)

什么是同步呢？同步就是指串行访问，在单线程的情况下，不用考虑同步的问题，因为不存在并行访问，而在多线程情况下，假设我们有个取款的方法，它可能是这样的：public static void 取款( int 款数 ){ int 余额 = get余额(); if( 余额>款数 ){ //代码1处吐钱(); //代码2处更新数据库余额(); }else{ System.

2017-04-09 16:01:42 501

原创基础篇:线程异常处理器与join方法(三)

在线程的run方法运行过程中，有可能抛出异常，这时你可能想这么来做：class UncaughtThread implements Runnable{ @Override public void run() { System.out.println("开始处理任务..."); //打印当前线程的私有异常处理器 System.out.println(Thread.currentT

2017-04-09 15:24:19 707

原创基础篇:获取线程返回值与守护线程的创建(二)

有时候，我们可能有需要拿到线程执行完毕的返回值的需求，这时我们可用通过java.util.concurrent.Future类与Callable接口来完成，如下所示：//必须实现Callable接口class MyCallable implements Callable{ private static int count = 0; private final int id = coun

2017-04-09 14:50:01 527

在java中，一个普通的类要成为一个可被java多线程机制调用的 "线程类" 有两种方式；继承Thread或者实现Runnable接口；如下所示：上面代码就是线程最基本的用法，创建以及启动，需要注意的是，必须调用线程类的start方法才是启动线程，调用run方法只是相当于调用一个普通的方法；我们看到，线程0和线程1毫无规律的交替执行，直到终止循环的条件shutCount的值变为0时才停止执行；在后面我们将学会采用多种互斥机制以及java提供的高级并发工具类来让线程间的执行变得有条理，而不是像这样混乱不堪

2017-04-09 10:56:51 544

原创 IOC实现之总结篇(六)

经过5篇文章，IOC的实现过程基本上已经讲清了，当然，还有些我没有讲，比如我们的组件扫描注解的实现又是怎样的，这点我原本打算写篇文章但想想还是放弃了，因为没有必要，看完上面5篇文章，相信你自己已经完全可以去理清注解的实现了！再回到IOC的话题，Spring的IOC作为一个完整的容器产品，通过对它源码的阅读，我们看到了它精妙绝伦的设计，无论是对资源文件的抽象还是对POJO的抽象，Spri

2017-04-04 10:35:24 439

原创 IOC实现之Bean的初始化(五)

现在我们开始来解析Bean的初始化过程，通过先前的一系列代码分析，我们得知当BeanFactory构建好后，也就意味着我们的bean配置全部转换成了BeanDefinition类且注册到了当前beanFactory之中，但此时Bean还没有被实例化，需要我们第一次使用到某个bean时，它才会被实例化，当然，也有额外情况，那就是配置了lazy-init为false时，启动容器时这个bean就会被实例

2017-04-03 19:06:03 470

原创 IOC实现之XML元素解析过程(四)

接着上篇文章我们继续来做构造器配置与属性配置的解析过程分析；我们先来看看BeanDefinitionParserDelegate是怎么来解析构造属性配置的；public void parseConstructorArgElements(Element beanEle, BeanDefinition bd) { //拿到子元素集合 NodeList nl = beanEle.getC

2017-04-03 12:48:20 508

原创 IOC实现之XML元素解析过程(三)

接着上篇文章的最后代码继续我们接下来的分析，接下来会进入下述方法中； //注册beanDefinition public int registerBeanDefinitions(Document doc, Resource resource) throws BeanDefinitionStoreException { //默认使用DefaultBeanDefinitionDocument

2017-04-03 11:02:28 717

原创 IOC实现之容器启动与资源定位(二)

回到我们的代码之中，当我们 new ClassPathXmlApplicationContext()时，就代表着在创建一个普通环境上下文，在其构造器中打下断点，我们跟随着断点一步步来往下看；public ClassPathXmlApplicationContext(String[] configLocations, boolean refresh, ApplicationContext par

2017-04-02 17:44:20 484

原创第十九篇:代理模式

代理模式大家应该都非常熟悉了吧，我们的spring中到处使用了代理，比如我们用声明式事物，写一个事物注解，当我们在调用目标对象的某个方法前，spring会先为我们开启一个事物，方法调用结束，spring会为我们提交事物...看起来我们好像是直接使用了目标对象调用了目标方法，而实际上却是使用的spring为我们创建的代理对象...关于这个话题这里不做展开，后续我会写数篇关于spring整个框架原理的解析博文，现在，我们举一个简单的例子，来展示下代理模式是怎么工作的！

2017-03-28 21:53:31 471

原创第十八篇:责任链模式

责任链就是链条式处理请求，当我们的请求到来，会经过一条对象链，这条链上有多个节点对象，它们都会对请求的数据进行解析处理，这样的话，后期如果要增加新的功能，只需要在链条中增加一个节点就可以了！就像我们servlet中Filter一样，每一个Filter都拦截处理请求，且处理完毕后交给下一个Filter进行处理，这就是典型的责任链模式；今天废话不多说，直接写责任链模式的代码；现在需要你为公司网站设计一个内容过滤系统，你应该怎么来做？简单的说，该功能就是将用户上传的文本内容进行验证与过滤！在动手写代码

2017-03-26 11:20:15 453

原创第十七篇:桥接模式

此模式主要用来解决复杂的类关系问题，通过抽象出多个类，从多个维度来描述解决问题，从而让混乱的类关系结构变得清晰；我们先来下个定义:桥接模式，用来将抽象部分与它的实现部分相分离，使它们可以独立的变化！这是什么意思呢？别急，往下看！

2017-03-26 11:06:02 396

原创第十六篇:备忘录模式

说在开头:其实我个人并不认为这是什么设计模式...因为完全没有什么价值嘛，不过既然多本书上对其有介绍，那我还是写一下吧！备忘录模式是用来实现备份，还原的一种代码组织结构；什么时候需要备份还原呢？非常常见的是游戏中的保存进度，打BOSS前需要先将当前进度保存一下，等到一不小心挂了，还可以马上恢复到打BOSS前...不然得江湖再见一切重头开始，那该多蛋疼？？？

2017-03-26 10:30:10 402

原创第十五篇:状态模式

什么是状态呢？这个非常好理解，就比如我们经常听到的一句广告词 “不在状态怎么办？脉动回来！！！” ，那么这就是状态的体现啦，这里的状态指的是你的精神，你的精神非常好，可能会赶紧看书工作，稍微差点，可能得眯眼休息下，差到完全处于懵逼状态，那你可能得选择好好休息睡个觉什么的了；所以你的精神状态决定了你接下来的行为，用代码来表示的话，状态就是一个变量，而变量的变化，直接影响程序的走向...今天我们就来举一个关于状态的例子，举个通俗易懂的吧，拿天气来举例 !

2017-03-26 10:09:33 411

原创第十四篇:原型模式

原型模式就是用来生成同样的对象的！比如你的简历，你创建好一份简历之后，通过打印机不断的打印就能创建出多份相同的简历出来，这些简历内容都是一模一样的的，用程序来表示的话，就是虽然对象不同(内存地址不同)，但属性都是一模一样...我们看看如果不用原型模式的话会是什么样子：

2017-03-26 09:46:17 315

原创第十三篇:建造者模式

见名之意，建造者就是用来建造对象的嘛！不过...等等，我们先前不是有工厂模式吗？我记得工厂模式也是用来创建对象的阿? 别着急，听我说！我们得将这两种模式区分一下，工厂模式是用来创建一个对象，它只初始化对象必须具备的属性，而建造者模式呢，是在创建完对象的基础上，再对对象进行一系列操作从而拿到更加完善的对象！就比如造房子，工厂模式就像是提供一个地基，而通过建造者模式，我们可以在有地基的基础上，再进行砌砖，打梁，盖瓦...等操作最终得到一个房子！

2017-03-26 09:33:22 343

原创 maven源码调试工具

当我们在使用工具包，框架的时候，为了深知原理或者解决bug，往往需要对源代码进行追踪调试，在没有maven的时代，需要手动下载源码jar包，然后在开发工具比如Eclipse中进行手动关联，才可以进行逐步调试，而maven则提供了Download Sources可以很方便的为我们自动下载源码；但是此时得到的源码虽然能看到，但是是不能调试的，无法打断点进行追踪，怎么办呢，先前我一直是手动去一个个关联源码jar包，这很痛苦的...比如调试spring的代码，有数个jar包需要跳进去看源码...每个ja

2017-03-20 17:19:18 559

原创第十二篇:组合模式

我们先了解一下组合模式吧！组合模式可以以树状形式来描述对象与对象的一组孩子之间的层次关系，运用组合模式，可以让个体以及个体下的组合(一组对象) 都使用同样的编程模型！也就是说，如果用了组合模式，无论是枝干节点还是叶子节点，我们都可用在上面调用一样的方法，我们不用去关心它到底是枝干还是叶子；

2017-03-17 21:23:30 263

原创第十一篇:迭代器模式

迭代器模式其实还是非常好理解的，因为我们无时无刻都在使用着迭代器模式，当我们用foreach语法遍历List集合，Set集合的，Map集合的时候，无形中就用到了java实现的迭代器，比如这样：

2017-03-17 21:22:50 312

原创写在开头:你为什么需要知道原理与解析准备工作

我一直对自己也对别人说，在你刚开始接触某件事物时，知其然而不知其所以然这是没有任何问题的，毕竟透过现象看本质这需要经验的累积与沉淀，然而，在我们编程这个行业，有太多工作三年，五年甚至更久的同学对自己经常所使用接触的技术还停留在会用的阶段；然而这些同学自认为自己的技术已经登峰造极，认为自己的能力水平早已达到高级工程师，高级架构师的水准，而本质上呢？本质上对各种技术的实现原理是一窍不通，不说网络通信和各种中间件的实现，就拿最常用的Spring来说，你的Bean是怎么生成的？IOC容器又是怎么来管理Bean的？

2017-03-14 11:21:48 545

原创 IOC实现之BeanFactory体系结构(一)

我们通过讲Spring的容器是怎样启动的，它在启动过程中做了些什么，以此来引发我们IOC原理的解析，在这里我们直接使用编程式的方式来启动容器，而不会涉及到SpringMVC，如果你担心你大多数时候是SpringMVC与Spring一起使用的，看这文章没有用，请放心，在后面解析SpringMVC的时候，你会发现，无论怎么变化，无非是启动容器的触发代码位置不同而已，这里是我们直接写代码，而SpringMVC会通过对Servlet的上下文监听而启动容器...

2017-03-14 11:18:44 396

原创第十篇:模板方法模式

通过画图，我们发现，其中某些步骤是完全固定的，那我们就可以思考，是不是可以有一个类，然后定义一个总的方法，这个方法就像是一个大的算法(把炒米粉看成是一个算法吧)骨架，或者说它就是一个模板，在这个方法中，它顺序调用不同的方法(步骤) ，先调用刷锅()，再放油()...接下来要解决放粉条的问题，怎么办，它自己不知道要放什么粉条，OK，抽象嘛，让子类来决定要放什么粉条咯！再接下来要放醋...到底放不放呢？放醋的过程是固定的，我们要复用这段代码，那怎么办呢？那具体放醋过程还是我们父类自己觉得，而到底要不要

2017-03-12 19:05:48 284

原创第九篇:装饰者模式

今天我们来谈谈装饰者模式！说起这个模式，相信大家都有过接触，java的IO体系总用过吧，IO体系中各种流都可以见到装饰者的影子，比如BufferedReader和Reader，通过向BufferedReader的构造函数中传入一个Reader，这个Reader就具备了缓冲的能力！再举个例子，比如你是一个光溜溜的人，给你套一件麻布衣服，你就成了一个平民，拥有了外出打酱油的能力(不穿衣服你敢出去？？？) ，再在你麻布衣服上套一层布甲，你成了一个低级士兵，拥有了战斗的能力！如果再在布甲上面套一层蝙蝠战

2017-03-12 19:05:04 354

原创第八篇:单例模式

关于单例模式我并不想做过多解释，网络上有一大堆关于它的定义，简而言之，单例就是指单个对象，整个程序的运行生命周期内某个对象只会生成一次！这么做有什么意义呢？很简单，你的电脑开机，有多个回收站对象会有什么后果?你删掉一个文件它该被放入哪个回收站？有多个注册表会怎样? 程序中有多个数据库连接池会怎样？这些问题留给你去思考吧！正因为某些对象的特殊性，整个程序生命周期内只能出现一个它的实例，又或者，某些对象的创建非常复杂非常消耗资源，且它是不会随着程序的运行而有所改变的，那么我们也期望只生产一次这个对象，

2017-03-12 19:04:28 380

空空如也

空空如也