亚洲色图激情文学,精品韩国亚洲av无码不卡区,亚洲成A人片77777国产

java classLoader 体系�l�构

陈睿 — Thu, 20 Jun 2013 02:25:00 GMT

版权信息: 可以��L��转蝲, 转蝲时请务必以超链接形式标明文章原文出处, 即下面的声明.

原文出处�Q?a style="text-decoration: none; color: #0044aa;">http://blog.chenlb.com/2009/06/java-classloader-architecture.html

jvm classLoader architecture�Q?/strong>

Bootstrap ClassLoader/启动�c�d��载器
主要负责jdk_home/lib目录下的核心(j��) api �?-Xbootclasspath 选项指定的jar包装入工作�?/li>
Extension ClassLoader/扩展�c�d��载器
主要负责jdk_home/lib/ext目录下的jar包或 -Djava.ext.dirs 指定目录下的jar包装入工作�?/li>
System ClassLoader/�pȝ��c�d��载器
主要负责java -classpath/-Djava.class.path所指的目录下的�c�M��jar包装入工作�?/li>
User Custom ClassLoader/用户自定义类加蝲�?java.lang.ClassLoader的子�c?
在程序运行期�? 通过java.lang.ClassLoader的子�c�d��态加载class文�g, 体现java动态实时类装入�Ҏ(gu��)��?/li>

�c�d��载器的特性：(x��)

每个ClassLoader都维护了(ji��n)一份自��q��名称�I�间�Q?同一个名�U�空间里不能出现两个同名的类�?/li>
��Z��(ji��n)实现java安全沙箱模型��层的类加蝲器安全机�? java默认采用�?" 双亲委派的加载链 " �l�构�?/li>

classloader-architecture

classloader-class-diagram

�c�d��中， BootstrapClassLoader是一个单独的java�c�，其实在这里，不应该叫他是一个java�c�R��因为，它已�l�完全不用java实现�?ji��n)。它是在jvm启动�Ӟ�� p��构造�v来的�Q?负责java�q�_��核心(j��)库�?/p>

自定义类加蝲器加载一个类的步�?/strong>

classloader-load-class

ClassLoader �c�d��载逻辑分析�Q?以下逻辑是除 BootstrapClassLoader 外的�c�d��载器加蝲��程�Q?/strong>

// ���(g��)查类是否已被装蝲�q?nbsp; 
Class c = findLoadedClass(name);  
if (c == null ) {  
     // 指定�c�L��被装载过  
     try {  
         if (parent != null ) {  
             // 如果父类加蝲器不为空�Q?nbsp;则委�z����父类加蝲  
             c = parent.loadClass(name, false );  
         } else {  
             // 如果父类加蝲器�ؓ(f��)�I�， 则委�z����启动�c�d��载加�?nbsp; 
             c = findBootstrapClass0(name);  
         }  
     } catch (ClassNotFoundException e) {  
         // 启动�c�d��载器或父�c�d��载器抛出异常后， 当前�c�d��载器���其  
         // 捕获�Q?nbsp;�q����过findClass�Ҏ(gu��)���Q?nbsp;��p���w�加�?nbsp; 
         c = findClass(name);  
     }  
}  

�U�程上下文类加蝲�?/strong>
java默认的线�E�上下文�c�d��载器�?�pȝ��c�d��载器(AppClassLoader)�?/p>

// Now create the class loader to use to launch the application  
try {  
    loader = AppClassLoader.getAppClassLoader(extcl);  
} catch (IOException e) {  
    throw new InternalError(  
"Could not create application class loader" );  
}   
  
// Also set the context class loader for the primordial thread.  
Thread.currentThread().setContextClassLoader(loader);  

以上代码摘自sun.misc.Launch的无参构造函数Launch()�?/p>

使用�U�程上下文类加蝲�? 可以在执行线�E�中, 抛弃双亲委派加蝲链模�? 使用�U�程上下文里的类加蝲器加载类.
典型的例子有, 通过�U�程上下文来加蝲�W�三方库jndi实现, 而不依赖于双亲委�z?
大部分java app服务�?jboss, tomcat..)也是采用contextClassLoader来处理web服务�?br />�q�有一些采�?hotswap �Ҏ(gu��)��的框架, 也��用了(ji��n)�U�程上下文类加蝲�? 比如 seasar (full stack framework in japenese).

�U�程上下文从�Ҏ(gu��)��解决�?ji��n)一般应用不能违背双亲委�z�模式的问题.
使java�c�d��载体�p�L��得更灉|��.

随着多核时代的来�? �怿�多线�E�开发将�?x��)越来越多地�q�入�E�序员的实际�~�码�q�程�? 因此,
在编写基��设施�Ӟ�� 通过使用�U�程上下文来加蝲�c? 应该是一个很好的选择�?/p>

当然, 好东襉K��有利�? 使用�U�程上下文加载类, 也要注意, 保证多根需要通信的线�E�间的类加蝲器应该是同一�?
防止因�ؓ(f��)不同的类加蝲�? ��D��c�d��转换异常(ClassCastException)�?/p>

��Z��么要使用�q�种双亲委托模式呢？

因�ؓ(f��)�q�样可以避免重复加蝲�Q�当父亲已经加蝲�?ji��n)该�cȝ��时候，��没有必要子ClassLoader再加载一�ơ�?/li>
考虑到安全因素，我们试想一下，如果不��用这�U�委托模式，那我们就可以随时使用自定义的String来动态替代java核心(j��)api中定义类型，�q�样�?x��)存在非常大的安全隐�?zh��n)�，而双亲委托的方式�Q�就可以避免�q�种情况�Q�因为String已经在启动时被加载，所以用戯��定义�c�L��无法加蝲一个自定义的ClassLoader�?/li>

java动态蝲入class的两�U�方式：(x��)

implicit隐式,卛_��用实例化才蝲入的�Ҏ(gu��)��来动态蝲入class
explicit昑ּ�方式,又分两种方式:
java.lang.Class的forName()�Ҏ(gu��)��
java.lang.ClassLoader的loadClass()�Ҏ(gu��)��

用Class.forName加蝲�c?/strong>

Class.forName使用的是被调用者的�c�d��载器来加载类的�?br />�q�种�Ҏ(gu��)�? 证明�?ji��n)java�c�d��载器中的名称�I�间是唯一�? 不会(x��)�怺��q�扰�?br />卛_��一般情况下, 保证同一个类中所兌��的其他类都是由当前类的类加蝲器所加蝲的�?/p>

public static Class forName(String className)  
     throws ClassNotFoundException {  
     return forName0(className, true , ClassLoader.getCallerClassLoader());  
}   
  
/** Called after security checks have been made. */  
private static native Class forName0(String name, boolean initialize,  
ClassLoader loader)  
     throws ClassNotFoundException;  

上面�?ClassLoader.getCallerClassLoader ��是得到调用当前forName�Ҏ(gu��)��的类的类加蝲�?/p>

static块在什么时候执�?

当调用forName(String)载入class时执�?如果调用ClassLoader.loadClass�q�不�?x��)执�?forName(String,false,ClassLoader)时也不会(x��)执行.
如果载入Class时没有执行static块则在第一�ơ实例化时执�?比如new ,Class.newInstance()操作
static块仅执行一��?/li>

各个java�cȝ��哪些classLoader加蝲?

java�c�d��以通过实例.getClass.getClassLoader()得知
接口由AppClassLoader(System ClassLoader,可以由ClassLoader.getSystemClassLoader()获得实例)载入
ClassLoader�cȝ��bootstrap loader载入

NoClassDefFoundError和ClassNotFoundException

NoClassDefFoundError:当java源文件已�~�译�?class文�g,但是ClassLoader在运行期间在其搜寻�\径load某个�c�L��,没有扑ֈ�.class文�g则报�q�个�?/li>
ClassNotFoundException:试图通过一个String变量来创��Z��个Class�c�L��不成功则抛出�q�个异常

陈睿 2013-06-20 10:25 发表评论

�l�构模式-Composite模式

陈睿 — Mon, 06 Aug 2012 09:49:00 GMT

一�Q��用场�?/strong>
   1�Q��用的地方�Q�树(w��i)形结构，分支�l�构�{?/p>
   2�Q��用的好处�Q�降低客��L(f��ng)��的��用，��Z��(ji��n)辑ֈ�元�g与组合�g使用的一致性，增加�?ji��n)元件的�~�码
   3�Q��用后的坏处：(x��)代码不容易理解，需要你认真�ȝ��IӞ��发现元�g与组合�g是怎么�l�合�?br />
二：(x��)一个实际的例子
    ��d��形，�q�个模式�Q�稍微要隄��解一点，有了(ji��n)例子��p��明了(ji��n)一切，我画的图是用接口做的�Q�代码实现是抽象�c�Mؓ(f��)基类�Q�你自己选择�?ji��n)，接口也可以�?/p>


1�Q�先建立囑�Ş元�g
   package com.mike.pattern.structure.composite;
/**
* 囑�Ş元�g
*
* @author taoyu
*
* @since 2010-6-23
*/
public abstract class Graph {
/**囑�Ş名称*/
protected String name;

public Graph(String name){
   this.name=name;
}

/**��d��*/
public abstract void draw()throws GraphException;

/**��d��囑�Ş*/
public abstract void add(Graph graph)throws GraphException;

/**�U�L��囑�Ş*/
public abstract void remove(Graph graph)throws GraphException;

}
2)建立基础囑�Ş�?/strong>
package com.mike.pattern.structure.composite;
import static com.mike.util.Print.print;
/**
* 圆图�?br />*
* @author taoyu
*
* @since 2010-6-23
*/
public class Circle extends Graph {
public Circle(String name){
   super(name);
}

/**
* 圆添加图�?br />* @throws GraphException
*/
@Override
public void add(Graph graph) throws GraphException {
   throw new GraphException("圆是基础囑�Ş�Q�不能添�?);
}
/**
* 圆画�?br />*/
@Override
public void draw()throws GraphException {
   print(name+"��d��?);
}
/**
* 圆移掉图�?br />*/
@Override
public void remove(Graph graph)throws GraphException {
   throw new GraphException("圆是基础囑�Ş�Q�不能移�?);
}
}
3�Q�徏立基��囑�Ş长方�?/strong>
package com.mike.pattern.structure.composite;
import static com.mike.util.Print.print;
/**
* 长方�?br />*
* @author taoyu
*
* @since 2010-6-23
*/
public class Rectangle extends Graph {
public Rectangle(String name){
   super(name);
}

/**
* 长方形添�?br />*/
@Override
public void add(Graph graph) throws GraphException {
   throw new GraphException("长方形是基础囑�Ş�Q�不能添�?);
}
/**
* 画长方�Ş
*/
@Override
public void draw() throws GraphException {
   print(name+"��d��?);
}
@Override
public void remove(Graph graph) throws GraphException {
   throw new GraphException("长方形是基础囑�Ş�Q�不能移�?);
}
}
4�Q�最后简历组合图�?/strong>
package com.mike.pattern.structure.composite;
import java.util.ArrayList;
import java.util.List;
import static com.mike.util.Print.print;
/**
* 囑�Ş�l�合�?br />*
* @author taoyu
*
* @since 2010-6-23
*/
public class Picture extends Graph {
private List graphs;

public Picture(String name){
   super(name);
   /**默认�?0个长�?/
   graphs=new ArrayList();
}

/**
* ��d��囑�Ş元�g
*/
@Override
public void add(Graph graph) throws GraphException {
   graphs.add(graph);
}

/**
* 囑�Ş元�g��d��
*/
@Override
public void draw() throws GraphException {
   print("囑�Ş容器�Q?+name+" 开始创�?);
   for(Graph g : graphs){
    g.draw();
   }
}
/**
* 囑�Ş元�g�U�L��囑�Ş元�g
*/
@Override
public void remove(Graph graph) throws GraphException {
   graphs.remove(graph);
}
}
5�Q�最后测�?/strong>
public static void main(String[] args)throws GraphException {
   /**��M��个圆�Q�圆里包含一个圆和长方�Ş*/
   Picture picture=new Picture("立方体圆");
   picture.add(new Circle("�?));
   picture.add(new Rectangle("长方�?));

   Picture root=new Picture("怪物囑�Ş");
   root.add(new Circle("�?));
   root.add(picture);
   root.draw();
}
6)使用�?j��)得�Q�的��降低了(ji��n)客户端的使用情况�Q�让整个囑�Ş可控�?ji��n)，当是你要深入�ȝ��解，才真名明白采用该模式的含义，不太��?gu��)��理解�?/p>

陈睿 2012-08-06 17:49 发表评论

陈睿 — Mon, 06 Aug 2012 09:38:00 GMT

一�Q��用场�?/strong>
     1�Q��用的地方�Q�我想��用两个不同类的方法，�q�个时候你需要把它们�l�合��h��使用
     2�Q�目前��用的情况�Q�我�?x��)把两个�cȝ��L(f��ng)��合的方式攑ֈ�一��P��~�程思想think in java里已�l�提��C��Q�能��量用组合就用组合，�l�承一般考虑再后�?/p>
     3�Q��用后的好处：(x��)你不需要改动以前的代码�Q�只是新��装�?ji��n)一新类�Q�由�q�个�c�L��提供两个�cȝ��Ҏ(gu��)��Q�这个时候：(x��)一定会(x��)惛_��facade外观模式�Q�本来是多个�c�M��用的情况�Q�我新封装成一个类来��用，而这个类我采用组合的方式来包装新的方法。我的理解是�Q�设计模式本�w�就是�ؓ(f��)�?ji��n)帮助解决特定的业务场景而故意把模式划分对应的模式类别，其实大多数情况，都解决了(ji��n)同样的问题，�q�个时候其实没有必要过多的�U�缠到模式的名字上了(ji��n)�Q�你有好的注意，你甚臛_��一个新的名字来概括�q�样的��用场景�?/p>
    4�Q��用的坏处�Q�适配器模式，有两�U�方式来实现。一个是�l�合一个是�l�承�Q�我觉得�Q�首先应该考虑�l�合�Q�能用组合就不要用��承，�q�是�W�一个。第二个�Q�你采用�l�承来实玎ͼ�那肯定会(x��)加大�l�承�?w��i)结构，如果你的�l�承关系本��n��很复杂�?ji��n)，�q�肯定会(x��)加大�l�承关系的维护，不有利于代码的理解，或则更加�J�琐。��承是��Z��(ji��n)解决重用的�ؓ(f��)题而出现的�Q�所以我觉得不应该滥用��承，有机�?x��)可以考虑同样别的�Ҏ(gu��)��?br />
二：(x��)一个实际的例子
      兌��营销的例子，用户购买完商品后�Q�我又推荐他相关别的商品
      �׃��减少代码�Q�方法我都不采用接口�Q�直接由�c�L��提供�Q�代码只是一个范例而已�Q�都�_��?ji��n)�?/p>
1)创徏订单信息
public class Order {
private Long orderId;
private String nickName;

public Order(Long orderId,String nickName){
   this.orderId=orderId;
   this.nickName=nickName;
}

/**
* 用户下订�?br />*/
public void insertOrder(){

}
}

2�Q�商品信�?/strong>
public class Auction {
/**商品名称*/
private String name;

/**刉��商*/
private String company;

/**刉��日�?/
private Date date;

public Auction(String name,String company, Date date){
   this.name=name;
   this.company=company;
   this.date=date;
}

/**
* 推广的商品列�?br />*/
public void commendAuction(){

}

}
3�Q�购�?/strong>
public class Trade {
/**用户订单*/
private Order order;

/**商品信息*/
private Auction auction;

public Trade(Order order ,Auction auction){
   this.order=order;
   this.auction=auction;
}

/**
* 用户产生订单以及(qi��ng)后箋(hu��)的事�?br />*/
public void trade(){
   /**下订�?/
   order.insertOrder();

   /**兌��推荐相关的商�?/
   auction.commendAuction();
}

}
   4�Q��用心(j��)得：(x��)其实外面采用�?ji��n)很多��承的方式�Q�order�l�承auction之后�Q�利用super .inserOrder()再加一个auction.recommendAuction(),实际上大同小异，我到觉得采用�l�合更容易理解以�?qi��ng)代码更加优��点�?/p>

陈睿 2012-08-06 17:38 发表评论

创徏模式-Builder模式

陈睿 — Mon, 06 Aug 2012 09:37:00 GMT

一�Q��用场�?/strong>
   1)使用到的地方�Q�如果你惛_��建类似汽车这��L(f��ng)��对象�Q�首先要创徏轮子�Q�玻璃，桌椅�Q�发动机�Q�外廓等�Q�这些部仉��创徏好后�Q�最后创建汽车成品，部�g的创建和汽�R的组装过�E�本�w�都很复杂的情况�Q�希望把部�g的创建和成品的组装分开来做�Q�这��h��要做的事情分割开来，降低对象实现的复杂度�Q�也降低以后成本的维护，把汽车的部�g创徏和组装过�E�独立出两个对应的工厂来做，有点�c�M��建立两个对应的部件创建工厂和汽�R�l�装工厂两个工厂�Q�而工厂只是创��Z��个成品，�q�没有把里面的步骤也独立出来�Q�应该说Builder模式比工厂模式又�q�了(ji��n)一步�?/p>
    2�Q�采用Builder模式后的好处�Q�把一个负责的对象的创��E�分解，把一个对象的创徏分成两个对象来负责创建，代码更有利于�l�护�Q�可扩性比较好�?/p>
   3�Q�采用Builder模式后的坏处�Q�实现�v来，对应的接口以�?qi��ng)部件的对象的创建比较多�Q�代码相�Ҏ(gu��)��Ԍ��比较多了(ji��n)�Q�估计刚开始你�?x��)有��?gu��)��Q�这个可以考虑代码�_��的问题，增加代码的可��L��?

二：(x��)一个实际的例子
汽�R的组�?/strong>
  1)首先创徏汽�R�q�个成品对象�Q�包含什么的成员
public class Car implements Serializable{

/**
* 汽�R序列�?br />*/
private static final long serialVersionUID = 1L;
/**汽�R轮子*/
private Wheel wheel;

/**汽�R发动�?/
private Engine engine;

/**汽�R�ȝ��*/
private Glass glass;

/**汽�R座椅*/
private Chair chair;

public Wheel getWheel() {
   return wheel;
}
public void setWheel(Wheel wheel) {
   this.wheel = wheel;
}
public Engine getEngine() {
   return engine;
}
public void setEngine(Engine engine) {
   this.engine = engine;
}
public Glass getGlass() {
   return glass;
}
public void setGlass(Glass glass) {
   this.glass = glass;
}
public Chair getChair() {
   return chair;
}
public void setChair(Chair chair) {
   this.chair = chair;
}

}
2�Q�创建对应汽车零部�g
public class Wheel {
public Wheel(){
   print("--汽�R轮子构徏完毕--");
}
}
public class Engine {
public Engine(){
   print("--汽�R发动机构建完�?-");
}
}
public class Glass {
public Glass(){
   print("--汽�R�ȝ��构徏完毕--");
}
}
public class Chair {
public Chair(){
   print("--汽�R座椅构徏完毕--");
}
}
3�Q�开始重点了(ji��n)�Q�汽车成品的�l�装�q�程
   public interface Builder {
/**�l�装汽�R轮子*/
public void buildWheel();

/**�l�装汽�R发动�?/
public void buildEngine();

/**�l�装汽�R�ȝ��*/
public void buildGlass();

/**�l�装汽�R座椅*/
public void buildChair();

/**�q�回�l�装好的汽�R*/
public Car getCar();
}
以及(qi��ng)实现�c?/p>
public class CarBuilder implements Builder {
/**汽�R成品*/
private Car car;

public CarBuilder(){
   car=new Car();
}

/**�l�装汽�R轮子*/
@Override
public void buildChair() {
   car.setChair(new Chair());
}
/**�l�装汽�R发动�?/
@Override
public void buildEngine() {
   car.setEngine(new Engine());
}
/**�l�装汽�R�ȝ��*/
@Override
public void buildGlass() {
   car.setGlass(new Glass());
}
/**�l�装汽�R座椅*/
@Override
public void buildWheel() {
   car.setWheel(new Wheel());
}

/**�q�回�l�装好的汽�R*/
@Override
public Car getCar() {
   buildChair();
   buildEngine();
   buildGlass();
   buildWheel();
   print("--整个汽�R构徏完毕--");
   return car;
}
}
4�Q�最后汽车创建测�?/strong>
   public static void main(String[] args) {
   /**创徏汽�R�l�装*/
   Builder carBuilder=new CarBuilder();
   Car car=carBuilder.getCar();
}
   最后输出：(x��)
--汽�R座椅构徏完毕--
--汽�R发动机构建完�?-
--汽�R�ȝ��构徏完毕--
--汽�R轮子构徏完毕--
--整个汽�R构徏完毕--
   5�Q?strong>体会(x��)�?j��)得�Q?/strong>Builder模式实际的重点就把汽车的�l�装�q�程和零部�g的生产分开来实玎ͼ�雉��件的生成主要靠自��q��对象来实玎ͼ�我上面只是在构造函数里创徏�?ji��n)，比较��单，而重�Ҏ(gu��)��车的�l�装则交�l�C(j��)arBuilder来实玎ͼ�最�l�由builder来先负责雉��件的创徏�Q�最后返回出成品的汽车�?/p>

陈睿 2012-08-06 17:37 发表评论

创徏模式-singleon单例模式

陈睿 — Mon, 06 Aug 2012 09:33:00 GMT

一�Q��用场�?br />
    1�Q�经�怋�用的地方�Q�一个类只有一个实例，eg:��面讉K��l�计pv�Q�统计的个数��只能保证一个实例的�l�计�?/p>
    2�Q�我们目前��用的情况�Q�比如我惛_��Z��个对象，�q�个对象希望只有一份实例的�l�护�Q�在内存的保存�(sh��)��只有一份，也就是在同一个jvm的java堆里只保存�(sh��)��份实例对象，所以你�?x��)想一办法�Q�在创徏�q�个对象的时候，��已�l�能保证只有一份�?/p>
    3�Q�怎么改进�Q�定义该对象的时候，��׃��证是同一份实例，比如�Q�定义�ؓ(f��)�U�有构造函敎ͼ�防止通过new的方式可以创建对象，然后在对象里定义一个静(r��n)态的�U�有成员�Q�本�w�对象的一个实例）(j��)�Q�然后再创徏一个外面访问该对象的方法就好了(ji��n)�?/p>
    4�Q�改�q�的好处�Q�代码在�~�译代码�q�个�U�别��p��控制�?ji��n)，不至于在jvm里运行的时候才来保证，把唯一实例的创��Z��证在�~�译阶段�Q�jvm里内存只有一份，从而内存占有率更低�Q�以�?qi��ng)更方便java垃圾回收
    5�Q�改�q�后的坏处：(x��)只能是代码稍微需要更多点�Q�其实大家最后发现改�q�后的坏处，都是代码定义比之间要多一点，但以后的�l�护代码��降下来�?ji��n)，也短暂的代码量偏大来换取以后代码的精��?br />
二：(x��)一个实际的例子
��M��的例�?/p>
package com.mike.pattern.singleton;
/**
* �ȝ��
*
* @author taoyu
*
* @since 2010-6-22
*/
public class President {
private President(){
   System.out.println("�ȝ��已经选�D出来�?);
}

/**�ȝ��只有一�?/
private static President president=new President();

/**
* �q�回�ȝ��
*/
public static President getPresident(){
   return president;
}

/**
* �ȝ��宣布选�D成功
*/
public void announce(){
   System.out.println("伟大的中国�h民，我将成你们新的�ȝ��");
}
}
/**
* @param args
*/
public static void main(String[] args) {
   President president=President.getPresident();
   president.announce();
}

陈睿 2012-08-06 17:33 发表评论

创徏模式-工厂模式

陈睿 — Mon, 06 Aug 2012 09:28:00 GMT

1.使用场景
     1�Q�子�c�过多，不容易管理；构造对象过�E�过长；�_��代码创徏�Q?br />
    2)目前我们代码情况�Q?�~�写代码的时候，我们�l�常都在new对象�Q�创��Z��个个的对象，而且�q�有很多�ȝ��(ch��)的创建方式，eg:HashMap grade=new HashMap(),�q�样的代码创建方式太冗长�?ji��n)，��N��你没有想�q�把�q�个创徏变的短一点么�Q�比如：(x��)HashMapgrade=HashMapFactory.new(),可以把你创徏�_��一点；你也可以�q�有别的需求，在创建对象的时候，你需要不同的情况�Q�创建统一�U�类别的对象�Q�eg:我想生成不同的汽车，创徏��车，创徏卡�R�Q�创建公交汽车等�{�，都属于同�U�类别：(x��)汽�R�Q�你��N��没有惌��Q�我把这些创建的对象在一个工厂里来负责创建，我把创徏分开化，交给一人来负责�Q�这样可以让代码更加�Ҏ(gu��)��理�Q�创建方式也可以��单点�?/p>
比如�Q�Car    BMW=CarFactory.create(bmw);   把创建new�׃��个统一负责�Q�这��L(f��ng)��理�v来相当方�?/p>
    3�Q�怎么改进�Q�这个时候，你会(x��)惛_��Q�创��样同�c�d��的东西，我把�q�个权利分出去，让一个�h来单独管理，它只负责创徏我的对象�q�个事情�Q�所以你单独��历一个对象来创徏同类的对象，�q�个时候，你想�q�个东西有点像工厂一��P��生成同样的��品，所以取�?ji��n)个名字�Q�工厂模式，��֐�思义�Q�只负责对象的创�?/p>
    4�Q�改�q�后的好处：(x��)代码更加�Ҏ(gu��)��理�?ji��n)，代码的创��z�很多�?/p>
    5�Q�改�q�后的坏处：(x��)那就是你需要单独加一个工厂对象来负责创徏�Q�多需要写点代码�?br />
2.一个实际的例子

   创徏宝马汽�R与奔驰汽车的例子
   1�Q�先提取��Z��个汽车的公用接口Car
       public interface Car{
          /**行驶*/
          public void drive();
        }

   2)宝马和奔驰汽车对�?/p>
public class BMWCar implements Car {
/**
* 汽�R发动
*/
public void drive(){
   System.out.println("BMW Car drive");
}
}
public class BengCar implements Car {
/**
* 汽�R发动
*/
public void drive(){
   System.out.println("BengChi Care drive");
}
}
    3)单独一个汽车工厂来负责创徏
     public class FactoryCar {
/**
* 刉��汽�?br />*
* @param company 汽�R公司
* @return 汽�R
* @throws CreateCarException 刉��汽车失败异�?br />*/
public static Car createCar(Company company)throws CreateCarException{
   if(company==Company.BMW){
    return new BMWCar();
   }else if(company==Company.Beng){
    return new BengCar();
   }
   return null;
}
}
    4�Q�最后的代码实现�Q?/p>
    Car BMWCar=FactoryCar.createCar(Company.BMW);
     BMWCar.drive();

陈睿 2012-08-06 17:28 发表评论

设计模式我的理解

陈睿 — Mon, 06 Aug 2012 09:22:00 GMT

1. 我说下我对设计模式的理解�Q��Q何一样事物都是因为有需求的驱动才诞生的�Q�所以设计模式也不例外，我们�q�x(ch��ng)��在编写代码的时候，随着旉��的深入，发现很多代码很难�l�护�Q�可扩展性��差，以及(qi��ng)代码的效率也比较低，�q�个时候你肯定�?x��)想办法让代码变的优��又能解决你��目中的问题�Q�所以在面向对象语言里，你肯定会(x��)��d��现很多可以重用的公用的方法，比如�Q�接口的存在�Q�你自然��想��C��(ji��n)�Q�让你定义的�Ҏ(gu��)��与你的实现分开�Q�也可以很方便把不同的类与接口匹配�v来，形成�?ji��n)一个公用的接口�Q�你�?x��)发现这样做�Q�好处会(x��)是非常多的，解决�?ji��n)你�q�x(ch��ng)��x(ch��ng)��代码的申明与逻辑实现的分开�?/p>
    2. �q�个时候，你发��C��(ji��n)�Q�本�w�面向对象的语言里，已经暗藏�?ji��n)很多好处，你肯定�?x��)仔细��d��析面向对象这个语�a��Q�认真去挖掘里面更多的奥�U�，最后，你发��C��(ji��n)�Q�原来你可以把面向对象的�Ҏ(gu��)��提取成一个公用的实现案例�Q�这些案例里能帮助你解决你��^时编写代码的困扰�Q�而这样一��h�Q�就是所谓gof的成员，他们从��^时设计徏�{�方面找��C��(ji��n)灉|��Q�徏�{�的设计也可以公用化以及(qi��ng)重用化，所以他们也提取�?ji��n)相关的软�g设计斚w��的公用案例，也就有了(ji��n)下面的相关的所�?3�U�设计模式，而里面这么多模式�Q�你也可以把他们归类��h��Q�最后发现就几类模式�Q�创建，�l�构�Q�行为等模式�c�d��Q�而这些现成的�Ҏ(gu��)��Q�也可以在实际应用中充分发挥作用�Q�随着大家的��用以�?qi��ng)理解，发现其实�q�些所谓的模式里，你的��可以让你的代码变的更加优美与简�l��?/p>
    3. 我比较喜�Ƣ把代码变的更加优美与简�l�，优美的代码就是一看就懂，�l�构很清晎ͼ�而简历就是一目了(ji��n)�?d��ng)��又可以解决你的问题，��是代码又少效率又高�Q�所以��^时要��L��写java doc的习(f��n)惯，�q�样的代码才为清晎ͼ�所以才�?x��)更加优��?/p>
    4. �q�些��是我对设计模式的理解，所以这么好的宝贝，我们不去深入的了(ji��n)解，的确可惜�?ji��n)，�q�就叫站到巨人的肩膀�?....

陈睿 2012-08-06 17:22 发表评论

操作�pȝ��-linux常用命��o(h��)

陈睿 — Tue, 24 Jul 2012 02:28:00 GMT

一�Q�网�l�配�|?/strong>

      1.��x(ch��ng)��防火�?
1) 重启后生�?nbsp;
开启：(x��) chkconfig iptables on
关闭�Q?chkconfig iptables off

2) ��x(ch��ng)��生效�Q�重启后失效
开启：(x��) service iptables start
关闭�Q?service iptables stop

    2.下蝲软�g
wget curl

    3.安装和解�?/div>
        安装 rpm -ivh
        升�� rpm -Uvh
        卸蝲 rpm -e
        tar -zxvf
　　
二：(x��)�|�卡讄��
　 1�?讄��ip地址�Q�即时生效，重启失效�Q?/div>
　　#ifconfig eth0 ip地址 netmask 子网掩码
　　
　　2�?讄��ip地址�Q�重启生效，�怹�生效�Q?/div>
　　#setup
　　
　　3�?通过配置文�g讄��ip地址�Q�重启生效，�怹�生效�Q?/div>
　　#vi /etc/sysconfig/network-scripts/ifcfg-eth0
　　DEVICE=eth0 #讑֤�名，与文件同名�?/div>
　　ONBOOT=yes #在系�l�启动时�Q�启动本讑֤��?/div>
　　BOOTPROTO=static
　　IPADDR=202.118.75.91 #此网卡的IP地址
　　NETMASK=255.255.255.0 #子网掩码
　　GATEWAY=202.118.75.1 #�|�关IP
　　MACADDR=00:02:2D:2E:8C:A8 #mac地址
　　
　　4�?重启�|�络服务
　　#service network restart //重启所有网�?/div>
　　
　　5�?��用�|�卡,启动�|�卡
　　#ifdown eth0
　　#ifup eth0
　　
　　6�?屏蔽�|�卡�Q�显�C�网�?/div>
　　#ifconfig eth0 down
　　#ifconfig eth0 up
　　
　　7�?配置DNS客户端（最多三个）(j��)
　　#vi /etc/resolv.conf
　　nameserver 202.99.96.68
　　
　　8、更改主机名�Q�即时生效）(j��)
　　#hostname ��L��?/div>
　　
　　9、更改主机名�Q�重启计��机生效�Q�永久生效）(j��)
　　#vi /etc/sysconfig/network
　　HOSTNAME=��L��?br />
三：(x��)两台l(f��)inux拯��命��o(h��)�Q�scp

1.安装scp:yum install openssh-clients

2.scp -r 本地用户名@IP地址:文�g�? �q�程用户名@IP地址:文�g�?

陈睿 2012-07-24 10:28 发表评论

服务�?Nginx

陈睿 — Fri, 06 Jul 2012 03:09:00 GMT
     摘要: 作�?NetSeek http://www.linuxtone.org (IT�q�维专家�|�|集群架构|性能调优)�Ƣ迎转蝲,转蝲时请务必以超链接形式标明文章原始出处和作者信息及(qi��ng)本声�?首发旉��: 2008-11-25 更新旉��:2009-1-14�?录一�?Nginx 基础知识二�?Nginx 安装�?qi��ng)调试三�?Nginx Rewrite四�?Nginx Redirect五�?Nginx 目录自动加斜�U?..  阅读全文

陈睿 2012-07-06 11:09 发表评论

框架-quartz

陈睿 — Tue, 03 Jul 2012 06:42:00 GMT
一�Q�quartz��?/strong>
OpenSymphony 的Quartz提供�?ji��n)一个比较完��的��d��调度解决�Ҏ(gu��)��?/span>
Quartz 是个开源的作业调度框架�Q�定时调度器�Q��ؓ(f��)�?Java 应用�E�序中进行作业调度提供了(ji��n)��单却强大的机制�?/div>
Quartz中有两个基本概念�Q�作业和触发器。作业是能够调度的可执行��d��Q�触发器提供�?ji��n)对作业的调�?br />
二：(x��)quartz spring配置详解
��Z��么不适用java.util.Timer�l�合java.util.TimerTask
      1.主要的原因，适用不方便，特别是制定具体的�q�月日时分的旉��Q�而quartz使用�c�M��linux上的cron配置�Q�很方便的配�|�每隔时间执行触发�?br />
    2.其次性能的原因，使用jdk自带的Timer不具备多�U�程�Q�而quartz采用�U�程池，性能上比timer高出很多�?br />

详解quartz在spring里面的配�|?/strong>
在spring里主要分��Z��U��用方式：(x��)�W�一�U�，也是目前使用最多的方式�Q�spring提供的MethodInvokingJobDetailFactoryBean代理�c�，通过雷利�cȝ��接调用�Q务类的某个函敎ͼ��W�二�U?�E�序里实现quartz接口�Q�quartz通过该接口进行调度�?br />
主要讲解通过spring提供的代理类MethodInvokingJobDetailFactoryBean

1.业务逻辑�c?业务逻辑是独立的�Q�本�w�就与quartz解耦的�Q��ƈ没有深入�q�去�Q�这对业务来讲是很好的一个方式�?br />
              public class  TestJobTask{


      /**
       *业务逻辑处理
       */
        public void   service(){
            /**业务逻辑*/
                ..
        }

}

2.增加一个线�E�池

<bean id="executor" class="org.springframework.scheduling.concurrent.ThreadPoolTaskExecutor">
<property name="corePoolSize" value="10" />
<property name="maxPoolSize" value="100" />
<property name="queueCapacity" value="500" />
bean>

3.定义业务逻辑�c?br />

<bean id="testJobTask" class="com.mike.scheduling.TestJobTask" />

4.增加quartz调用业务逻辑


<bean id="jobDetail" class="org.springframework.scheduling.quartz.MethodInvokingJobDetailFactoryBean">
<property name="targetObject" ref="testJobTask" />
<property name="targetMethod" value="service" />
bean>

5.增加调用的触发器�Q�触发的旉��Q�有两种方式�Q?br />
�W�一�U�触发时��_(d��)��采用�c�M��linux的cron�Q�配�|�时间的表示发出丰富
<bean id="cronTrigger" class="org.springframework.scheduling.quartz.CronTriggerBean">
<property name="jobDetail" ref="jobDetail" />
<property name="cronExpression" value="10 0/1 * * * ?" />
bean>
  Cron表达�?#8220;10 */1 * * * ?”意�ؓ(f��)�Q�从10�U�开始，�?分钟执行一��?/span>

�W�二�U�，采用比较��话的方式�Q�申明�g�q�时间和间隔旉��
<bean id="taskTrigger" class="org.springframework.scheduling.quartz.SimpleTriggerBean">
<property name="jobDetail" ref="jobDetail" />
<property name="startDelay" value="10000" />
<property name="repeatInterval" value="60000" />
bean>
  延迟10�U�启动，然后每隔1分钟执行一��?/span>

6.开始调�?br />

<bean class="org.springframework.scheduling.quartz.SchedulerFactoryBean">
<property name="triggers">
  <list>
   <ref bean="cronTrigger" />
  list>
property>
<property name="taskExecutor" ref="executor" />
bean>

7.�l�束�Q�启动容器即可，已经��spring和quartz�l�合完毕�?/strong>

Cron常用的表辑ּ�
  "0 0 12 * * ?" 每天中午12点触�?/span>
"0 15 10 ? * *" 每天上午10:15触发
"0 15 10 * * ?" 每天上午10:15触发
"0 15 10 * * ? *" 每天上午10:15触发
"0 15 10 * * ? 2005" 2005�q�的每天上午10:15触发
"0 * 14 * * ?" 在每天下�?点到下午2:59期间的每1分钟触发
"0 0/5 14 * * ?" 在每天下�?点到下午2:55期间的每5分钟触发
"0 0/5 14,18 * * ?" 在每天下�?点到2:55期间和下�?点到6:55期间的每5分钟触发
"0 0-5 14 * * ?" 在每天下�?点到下午2:05期间的每1分钟触发
"0 10,44 14 ? 3 WED" 每年三月的星期三的下�?:10�?:44触发
"0 15 10 ? * MON-FRI" 周一臛_��五的上午10:15触发
"0 15 10 15 * ?" 每月15日上�?0:15触发
"0 15 10 L * ?" 每月最后一日的上午10:15触发
"0 15 10 ? * 6L" 每月的最后一个星期五上午10:15触发
"0 15 10 ? * 6L 2002-2005" 2002�q�至2005�q�的每月的最后一个星期五上午10:15触发
"0 15 10 ? * 6#3" 每月的第三个星期五上�?0:15触发

三：(x��)quartz原理

�Ҏ(gu��)��上面spring的配�|�，我们��比较清楚quartz的内部情况，下面我们主要详解配置涉及(qi��ng)到的每个�?/strong>
1.我们先从最后一个步骤看��P��SchedulerFactoryBean �Q�scheduler的工厂实玎ͼ�里面可以生��出对应的多个jobDetail和trigger�Q�每个jobDetail对应trigger代表一个�Q�?br />    Quartz的SchedulerFactory是标准的工厂�c�，不太适合在Spring环境下��用。此外，��Z��(ji��n)保证Scheduler能够感知 Spring容器的生命周期，完成自动启动和关闭的操作�Q�必��让Scheduler和Spring容器的生命周期相兌��。以便在Spring容器启动后， Scheduler自动开始工作，而在Spring容器关闭前，自动关闭Scheduler。�ؓ(f��)此，Spring提供 SchedulerFactoryBean�Q�这个FactoryBean大致拥有以下的功能：(x��)
1)以更具Bean风格的方式�ؓ(f��)Scheduler提供配置信息�Q?nbsp;
2)让Scheduler和Spring容器的生命周期徏立关联，相生相息�Q?nbsp;
3)通过属性配�|�部分或全部代替Quartz自��n的配�|�文件�?nbsp;
2.jobDetail,表示一个可执行的业务调�?br />
3.trigger:调度的时间计划，什么时候，每隔多少旉��可执行等旉��计划

4.ThreadPoolTaskExecutor�Q�线�E�池�Q�用来�ƈ行执行每个对应的job�Q�提高效率，�q�也是上面提��C��推荐使用jdk自��ntimer的一个很重要的原�?/span>

陈睿 2012-07-03 14:42 发表评论