<?xml version="1.0" encoding="utf-8" ?><rss version="2.0"><channel><title><![CDATA[飘零的云]]></title><description><![CDATA[fly with wind like cloud]]></description><link>https://blog.youkuaiyun.com/micky2046</link><language>zh-cn</language><generator>https://blog.youkuaiyun.com/</generator><copyright><![CDATA[Copyright &copy; micky2046]]></copyright><item><title><![CDATA[使用Spring的事务管理----传播性和隔离性]]></title><link>https://blog.youkuaiyun.com/micky2046/article/details/84616177</link><guid>https://blog.youkuaiyun.com/micky2046/article/details/84616177</guid><author>micky2046</author><pubDate>Fri, 18 Jul 2014 16:46:42 +0800</pubDate><description><![CDATA[
在上面几篇日志配置Spring事务的时候都涉及到了事务的传播和隔离性，这里具体深入理解一下。
当多个事务嵌套时，某个事务的propagation事务传播将会直接影响最终的执行效果。
具体propagation的解释如下：


propagation属性
说明



 REQUIRED
 无论当前事务上下文中有没有事务，都会创建一个新的事务。也即逻辑需要在一个事务中运行,如果方法运行...]]></description><category></category></item><item><title><![CDATA[使用Spring的事务模板]]></title><link>https://blog.youkuaiyun.com/micky2046/article/details/84615860</link><guid>https://blog.youkuaiyun.com/micky2046/article/details/84615860</guid><author>micky2046</author><pubDate>Thu, 17 Jul 2014 20:33:58 +0800</pubDate><description><![CDATA[
整体的工程代码跟上一篇日志的工程差不多。
服务类StudentService.java的代码如下：
package com.mysrc.service;

import java.sql.Date;
import java.util.List;

import org.springframework.transaction.TransactionStatus;
import o...]]></description><category></category></item><item><title><![CDATA[使用Spring的声明式事务----AOP方式 ]]></title><link>https://blog.youkuaiyun.com/micky2046/article/details/84615801</link><guid>https://blog.youkuaiyun.com/micky2046/article/details/84615801</guid><author>micky2046</author><pubDate>Thu, 17 Jul 2014 17:35:59 +0800</pubDate><description><![CDATA[
类似于上一篇日志，这里使用AOP的方式来配置。
工程结构：

大部分代码跟上一个工程类似。
 
服务类StudentService.java代码如下：
package com.mysrc.service;

import java.sql.Date;
import java.util.List;

import com.mysrc.dao.StudentDao;
imp...]]></description><category></category></item><item><title><![CDATA[使用Spring的声明式事务----Annotation注解方式]]></title><link>https://blog.youkuaiyun.com/micky2046/article/details/84615780</link><guid>https://blog.youkuaiyun.com/micky2046/article/details/84615780</guid><author>micky2046</author><pubDate>Thu, 17 Jul 2014 17:15:15 +0800</pubDate><description><![CDATA[
这里列一个小的demo工程，直接利用Spring的jdbcTemplate访问Mysql数据库。
工程结构：
 
数据库中的tbl_student表结构如下：

 
数据实体类Student.java代码如下： 
package com.mysrc.entity;

import java.sql.Date;

public class Student {
	priva...]]></description><category></category></item><item><title><![CDATA[应用Spring AOP（六）-------Annotation注解配置方式]]></title><link>https://blog.youkuaiyun.com/micky2046/article/details/84494117</link><guid>https://blog.youkuaiyun.com/micky2046/article/details/84494117</guid><author>micky2046</author><pubDate>Wed, 30 Oct 2013 14:53:31 +0800</pubDate><description><![CDATA[
Spring AOP的注解方式在官网的doc文档里也有详细的说明：http://docs.spring.io/spring/docs/2.0.8/reference/aop.html
还是上篇日志的示例工程，现在换成Annotation注解的方式来配置AOP，工程结构一样的： AllLogAdvice类代码变成了如下：
package com.aop;

import org.apac...]]></description><category></category></item><item><title><![CDATA[应用Spring AOP（五）-------XML配置方式]]></title><link>https://blog.youkuaiyun.com/micky2046/article/details/84493944</link><guid>https://blog.youkuaiyun.com/micky2046/article/details/84493944</guid><author>micky2046</author><pubDate>Wed, 30 Oct 2013 10:04:06 +0800</pubDate><description><![CDATA[
Spring AOP提供了xml配置文件以及Annotation注解的方式更方便的进行AOP的配置。当然这两种方式的最大的好处是更好的降低了代码耦合性。
XML配置的示例工程代码： 和前面的工程相比，前置通知，后置通知那几个通知类没有了，所有的通知逻辑直接放到了AllLogAdvice类的方法里：
package com.aop;

import org.apache.log4j.Lo...]]></description><category></category></item><item><title><![CDATA[应用Spring AOP（四）-------原理]]></title><link>https://blog.youkuaiyun.com/micky2046/article/details/84493746</link><guid>https://blog.youkuaiyun.com/micky2046/article/details/84493746</guid><author>micky2046</author><pubDate>Tue, 29 Oct 2013 16:25:30 +0800</pubDate><description><![CDATA[
       记得参加今年的网易校招Java研发工程师职位的笔试题中就有类似的这个题目，还好之前看过网上的介绍，而且阿里巴巴一面的时候这个知识点也帮了我的大忙，嘿嘿。。
这篇文章太有用了，讲得很透彻：http://www.blogjava.net/DoubleJ/archive/2008/03/04/183796.html
大体就是应用动态代理，说白了就是反射+代理模式，其中java.la...]]></description><category></category></item><item><title><![CDATA[应用Spring AOP（三）-------使用控制流切入点]]></title><link>https://blog.youkuaiyun.com/micky2046/article/details/84493739</link><guid>https://blog.youkuaiyun.com/micky2046/article/details/84493739</guid><author>micky2046</author><pubDate>Tue, 29 Oct 2013 16:12:19 +0800</pubDate><description><![CDATA[
        如果只想拦截在某种情况下调用的方法，可以使用Spring AOP提供的ControlFlowPointcut来完成这个功能。比如，只有在MainTest类中的aaMethod方法中调用的目标类的方法才会被拦截，其它地方调用的目标类的方法将不会被拦截。
        示例如下，应用上一篇日志的前置通知，不同就是这里应用ControlFlowPointcut，而上一篇日志应用了...]]></description><category></category></item><item><title><![CDATA[应用Spring AOP（二）-------通过Advisor指定切入点]]></title><link>https://blog.youkuaiyun.com/micky2046/article/details/84493721</link><guid>https://blog.youkuaiyun.com/micky2046/article/details/84493721</guid><author>micky2046</author><pubDate>Tue, 29 Oct 2013 15:20:17 +0800</pubDate><description><![CDATA[
       上一篇日志使用的前置通知，后置通知，环绕通知和异常通知可以很好的拦截方法，并插入相应的代码。但是却存在一个问题，就是Spring AOP拦截了目标类中的所有方法。而在通常情况下，只需要拦截部分方法，比如只需要拦截目标类中方法名以set开始的所有方法。Spring AOP提供了Advisor和PointcutAdvisor来达到这个目的。
       常用的PointAdvis...]]></description><category></category></item><item><title><![CDATA[应用Spring AOP（一）]]></title><link>https://blog.youkuaiyun.com/micky2046/article/details/84493487</link><guid>https://blog.youkuaiyun.com/micky2046/article/details/84493487</guid><author>micky2046</author><pubDate>Mon, 28 Oct 2013 22:16:19 +0800</pubDate><description><![CDATA[
        AOP即Aspect-Oriented Programming，面向方面编程。AOP和OOP类似，也是一种编程模式。但是AOP并不能取代OOP，它只是对OOP的扩展和补充。Spring AOP是基于AOP编程模式的一个框架，它实现了AOP范围内的大多数功能，包括Advice、Pointcut等。
        AOP典型的应用场景：
http://pandonix.ite...]]></description><category></category></item><item><title><![CDATA[用JUnit4进行单元测试]]></title><link>https://blog.youkuaiyun.com/micky2046/article/details/84484331</link><guid>https://blog.youkuaiyun.com/micky2046/article/details/84484331</guid><author>micky2046</author><pubDate>Sat, 28 Sep 2013 20:00:36 +0800</pubDate><description><![CDATA[
用Junit进行单元测试很方便，尤其是Junit4引入了很多Annotation注解以后。看测试的示例：
待测试类：
public class Calculator {

	public int add(int a, int b) {
		return a + b;
	}

	public int minus(int a, int b) {
		return a - b;
...]]></description><category></category></item><item><title><![CDATA[Java中的ThreadLocal]]></title><link>https://blog.youkuaiyun.com/micky2046/article/details/84484286</link><guid>https://blog.youkuaiyun.com/micky2046/article/details/84484286</guid><author>micky2046</author><pubDate>Sat, 28 Sep 2013 16:21:39 +0800</pubDate><description><![CDATA[
再了解ThreadLocal之前先看一个简单的Java线程示例。
线程类：
public class TestThread2 extends Thread {
	int a;
	String b = &quot;a&quot;;

	@Override
	public void run() {
		for (int i = 1; i &amp;lt;= 3; i++) {
			System.out.p...]]></description><category></category></item><item><title><![CDATA[有关Java序列化（三）——使用Externalizable]]></title><link>https://blog.youkuaiyun.com/micky2046/article/details/84484107</link><guid>https://blog.youkuaiyun.com/micky2046/article/details/84484107</guid><author>micky2046</author><pubDate>Fri, 27 Sep 2013 21:48:21 +0800</pubDate><description><![CDATA[
JDK中提供了另一个序列化接口--Externalizable，使用该接口之后，之前基于Serializable接口的序列化机制就将失效。Externalizable继承于Serializable，当使用该接口时，序列化的细节需要由程序员去完成。
测试代码：
import java.io.Externalizable;
import java.io.IOException;
impor...]]></description><category></category></item><item><title><![CDATA[有关Java序列化（二）]]></title><link>https://blog.youkuaiyun.com/micky2046/article/details/84484095</link><guid>https://blog.youkuaiyun.com/micky2046/article/details/84484095</guid><author>micky2046</author><pubDate>Fri, 27 Sep 2013 21:10:32 +0800</pubDate><description><![CDATA[
还是上一篇日志的测试代码：
import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.io.Serializable;

public class Person implements Serializable {

	p...]]></description><category></category></item><item><title><![CDATA[有关Java序列化（一）]]></title><link>https://blog.youkuaiyun.com/micky2046/article/details/84484078</link><guid>https://blog.youkuaiyun.com/micky2046/article/details/84484078</guid><author>micky2046</author><pubDate>Fri, 27 Sep 2013 20:12:31 +0800</pubDate><description><![CDATA[
“序列化是将对象状态转换为可保持或可传输的格式的过程”。为什么要序列化，说的很清楚了，就是为了将对象状态进行持久化或者进行传输。注意这里说的是对象状态，所以只有对象的属性变量才会进行序列化，方法是不会序列化的。Java中所有实现Serializable接口的对象就表明是可序列化的。
 
示例代码：
import java.io.Serializable;

public class ...]]></description><category></category></item><item><title><![CDATA[Java处理正则表达式]]></title><link>https://blog.youkuaiyun.com/micky2046/article/details/84476593</link><guid>https://blog.youkuaiyun.com/micky2046/article/details/84476593</guid><author>micky2046</author><pubDate>Thu, 05 Sep 2013 15:01:41 +0800</pubDate><description><![CDATA[
Java本身的Util包里面就有提供处理正则表达式的工具类，当然还有很多第三方正则表达式处理包，反正到目前为止，用java.util.regex就已经能满足我的需求了。示例如下：
import java.util.regex.Matcher;
import java.util.regex.Pattern;

public class Hello {
	public static vo...]]></description><category></category></item><item><title><![CDATA[Java线程通信实现生产者-消费者]]></title><link>https://blog.youkuaiyun.com/micky2046/article/details/84476308</link><guid>https://blog.youkuaiyun.com/micky2046/article/details/84476308</guid><author>micky2046</author><pubDate>Wed, 04 Sep 2013 20:02:22 +0800</pubDate><description><![CDATA[
生产者消费者是经典的线程之间同步通信问题，生产者线程只有在产品仓库中没有产品的时候才生产产品，当它生成完一个产品以后唤醒消费者线程，消费者线程只有在产品仓库中有产品的时候才能取走产品，然后唤醒生产者线程。
Java可以有好几种方法解决这个问题。首先基础的当然是用Object的wait()、notify()和notifyAll()。
产品仓库类：
//产品仓库
public class ...]]></description><category></category></item><item><title><![CDATA[使用Java的BlockingQueue实现生产者-消费者]]></title><link>https://blog.youkuaiyun.com/micky2046/article/details/84476180</link><guid>https://blog.youkuaiyun.com/micky2046/article/details/84476180</guid><author>micky2046</author><pubDate>Wed, 04 Sep 2013 16:00:58 +0800</pubDate><description><![CDATA[
BlockingQueue也是java.util.concurrent下的主要用来控制线程同步的工具。
BlockingQueue有四个具体的实现类,根据不同需求,选择不同的实现类1、ArrayBlockingQueue：一个由数组支持的有界阻塞队列，规定大小的BlockingQueue,其构造函数必须带一个int参数来指明其大小.其所含的对象是以FIFO(先入先出)顺序排序的。
2、Li...]]></description><category></category></item><item><title><![CDATA[Java调用Python]]></title><link>https://blog.youkuaiyun.com/micky2046/article/details/84465376</link><guid>https://blog.youkuaiyun.com/micky2046/article/details/84465376</guid><author>micky2046</author><pubDate>Fri, 02 Aug 2013 19:51:07 +0800</pubDate><description><![CDATA[
今天遇到Java调用一个Python脚本的问题，纠结了大半天，遇到各种问题。网上搜索的大部分都是用jython，但是我想要调用的python脚本里有import urllib，这个urllib也不是什么第三方扩展库，在python的安装path下的Lib下就有，在python命令行下肯定是能找到的。但是用jython的话，sys的path里面就太少了。示例代码：
import org.pyth...]]></description><category></category></item><item><title><![CDATA[Java中使用Lock控制线程同步]]></title><link>https://blog.youkuaiyun.com/micky2046/article/details/84436035</link><guid>https://blog.youkuaiyun.com/micky2046/article/details/84436035</guid><author>micky2046</author><pubDate>Mon, 27 May 2013 21:42:12 +0800</pubDate><description><![CDATA[
紧接着Callable和线程池，再次接触java.util.concurrent并发包下的东西。Lock提供比synchronized更灵活的并发控制。Lock是java.util.concurrent.locks包下的接口，Lock 实现提供了比使用synchronized 方法和语句可获得的更广泛的锁定操作，它能以更优雅的方式处理线程同步问题。使用最多的Lock类是ReentrantLoc...]]></description><category></category></item></channel></rss>