收藏私塾在线
 

欢迎您来到私塾在线网!   

请登录! 

免费注册 


javasscc的笔记
状态: 离线
人气:510565
访问用户量:1143
笔记经验:
总积分:1958
级别:普通会员
搜索本笔记
ta的交流分类
ta的交流主题贴(196)
ta的所有交流贴(200)
ta的全部笔记
全部笔记(98)
未分类笔记(0)
研磨设计模式(94)
课程问题(0)
设计模式综合项目实战(4)
存档
2013-05(4)
2012-08(39)
2012-07(55)

2013-01-16 17:24:18
研磨设计模式 之 原型模式(Prototype)3 ——跟着cc学设计系列
浏览(6323)|评论(1)   交流分类:Java|笔记分类: 研磨设计模式

9.3  模式讲解

9.3.1  认识原型模式

(1)原型模式的功能

原型模式的功能实际上包含两个方面:

  • 一个是通过克隆来创建新的对象实例
  • 另一个是为克隆出来的新的对象实例复制原型实例属性的值

原型模式要实现的主要功能就是:通过克隆来创建新的对象实例。一般来讲,新创建出来的实例的数据是和原型实例一样的。但是具体如何实现克隆,需要由程序自行实现,原型模式并没有统一的要求和实现算法。

(2)原型与new

原型模式从某种意义上说,就像是new操作,在前面的例子实现中,克隆方法就是使用new来实现的,但请注意,只是“类似于new”而不是“就是new”。

克隆方法和new操作最明显的不同就在于:new一个对象实例,一般属性是没有值的,或者是只有默认值;如果是克隆得到的一个实例,通常属性是有值的,属性的值就是原型对象实例在克隆的时候,原型对象实例的属性的值。

(3)原型实例和克隆的实例

原型实例和克隆出来的实例,本质上是不同的实例,克隆完成后,它们之间是没有关联的,如果克隆完成后,克隆出来的实例的属性的值发生了改变,是不会影响到原型实例的。下面写个示例来测试一下,示例代码如下:

public class Client {

    public static void main(String[] args) {

       //先创建原型实例

       OrderApi oa1 = new PersonalOrder();

      

       //设置原型实例的订单数量的值

       oa1.setOrderProductNum(100);

       //为了简单,这里仅仅输出数量

        System.out.println("这是第一次获取的对象实例==="

+oa1.getOrderProductNum());

       

       //通过克隆来获取新的实例

        OrderApi oa2 = (OrderApi)oa1.cloneOrder();

       //修改它的数量

       oa2.setOrderProductNum(80);

       //输出克隆出来的对象的值

       System.out.println("输出克隆出来的实例==="

+oa2.getOrderProductNum());

      

       //再次输出原型实例的值

       System.out.println("再次输出原型实例==="

+oa1.getOrderProductNum());  

    }

}

运行一下,看看结果:

这是第一次获取的对象实例===100

输出克隆出来的实例===80

再次输出原型实例===100

仔细观察上面的结果,会发现原型实例和克隆出来的实例是完全独立的,也就是它们指向不同的内存空间。因为克隆出来的实例的值已经被改变了,而原型实例的值还是原来的值,并没有变化,这就说明两个实例是对应的不同内存空间。

(4)原型模式的调用顺序示意图

原型模式的调用顺序如图9.3所示:

 

图9.3  原型模式的调用顺序示意图

9.3.2  Java中的克隆方法

在Java语言中已经提供了clone方法,定义在Object类中。关于Java中clone方法的知识,这里不去赘述,下面看看怎么使用Java里面的克隆方法来实现原型模式。

       需要克隆功能的类,只需要实现java.lang.Cloneable接口,这个接口没有需要实现的方法,是一个标识接口。因此在前面的实现中,把订单接口中的克隆方法去掉,现在直接实现Java中的接口就好了。新的订单接口实现,示例代码如下:

public interface OrderApi {

    public int getOrderProductNum();

    public void setOrderProductNum(int num);

    public OrderApi cloneOrder();

}

另外在具体的订单实现对象里面,实现方式上会有一些改变,个人订单和企业订单的克隆实现是类似的,因此示范一个就好了,看看个人订单的实现吧,示例代码如下:

/**

 * 个人订单对象,利用Java的Clone功能

 */

public class PersonalOrder implements Cloneable  , OrderApi{

    private String customerName;

    private String productId;

    private int orderProductNum = 0;

    public int getOrderProductNum() {

       return this.orderProductNum;

    }  

    public void setOrderProductNum(int num) {

       this.orderProductNum = num;

    }  

    public String getCustomerName() {

       return customerName;

    }

    public void setCustomerName(String customerName) {

       this.customerName = customerName;

    }

    public String getProductId() {

       return productId;

    }

    public void setProductId(String productId) {

       this.productId = productId;

    }

    public String toString(){

       return "本个人订单的订购人是="+this.customerName

+",订购产品是="+this.productId+",订购数量为="

+this.orderProductNum;

    }

    public OrderApi cloneOrder() {

       // 创建一个新的订单,然后把本实例的数据复制过去

       PersonalOrder order = new PersonalOrder();

       order.setCustomerName(this.customerName);

       order.setProductId(this.productId);

       order.setOrderProductNum(this.orderProductNum);     

       return order;

    }

    public Object clone(){

       //克隆方法的真正实现,直接调用父类的克隆方法就可以了

       Object obj = null;

       try {

           obj = super.clone();

       } catch (CloneNotSupportedException e) {

           e.printStackTrace();

       }

       return obj;

    }

}

       看起来,比完全由自己实现原型模式要稍稍简单点,是否好用呢?还是测试一下,看看效果。客户端跟上一个示例相比,作了两点修改:

  • 一个是原来的“OrderApi oa1 = new PersonalOrder();”这句话,要修改成:“PersonalOrder oa1 = new PersonalOrder();”。原因是现在的接口上并没有克隆的方法,因此需要修改成原型的类型
  • 另外一个是“通过克隆来获取新的实例”的实现,需要修改成使用原型来调用在Object里面定义的clone()方法了,不再是调用原来的cloneOrder()了。

看看测试用的代码,示例代码如下:

public class Client {

    public static void main(String[] args) {

       //先创建原型实例

       PersonalOrder oa1 = new PersonalOrder();     

       //设置原型实例的订单数量的值

       oa1.setOrderProductNum(100);

        System.out.println("这是第一次获取的对象实例==="

+oa1.getOrderProductNum());      

       //通过克隆来获取新的实例

        PersonalOrder oa2 = (PersonalOrder)oa1.clone();

       oa2.setOrderProductNum(80);

       System.out.println("输出克隆出来的实例==="

+oa2.getOrderProductNum());     

       //再次输出原型实例的值

       System.out.println("再次输出原型实例==="

+oa1.getOrderProductNum());  

    }

}

去运行一下,测试看看。

9.3.3  浅度克隆和深度克隆

无论你是自己实现克隆方法,还是采用Java提供的克隆方法,都存在一个浅度克隆和深度克隆的问题,那么什么是浅度克隆?什么是深度克隆呢?简单地解释一下:

  • 浅度克隆:只负责克隆按值传递的数据(比如:基本数据类型、String类型)
  • 深度克隆:除了浅度克隆要克隆的值外,还负责克隆引用类型的数据,基本上就是被克隆实例所有的属性的数据都会被克隆出来。
        深度克隆还有一个特点,如果被克隆的对象里面的属性数据是引用类型,也就是属性的类型也是对象,那么需要一直递归的克隆下去。这也意味着,要想深度克隆成功,必须要整个克隆所涉及的对象都要正确实现克隆方法,如果其中有一个没有正确实现克隆,那么就会导致克隆失败。

       在前面的例子中实现的克隆就是典型的浅度克隆,下面就来看看如何实现深度克隆。

1:自己实现原型的深度克隆

(1)要演示深度克隆,需要给订单对象添加一个引用类型的属性,这样实现克隆过后,才能看出深度克隆的效果来。

那就定义一个产品对象,也需要让它实现克隆的功能,产品对象实现的是一个浅度克隆。先来定义产品的原型接口,示例代码如下:

/**

 * 声明一个克隆产品自身的接口

 */

public interface ProductPrototype {

    /**

     * 克隆产品自身的方法

     * @return 一个从自身克隆出来的产品对象

     */

    public ProductPrototype cloneProduct();

}

接下来看看具体的产品对象实现,示例代码如下:

/**

 * 产品对象

 */

public class Product implements ProductPrototype{

    /**

     * 产品编号

     */

    private String productId;  

    /**

     * 产品名称

     */

    private String name;

    public String getName() {

       return name;

    }

    public void setName(String name) {

       this.name = name;

    }

    public String getProductId() {

       return productId;

    }

    public void setProductId(String productId) {

       this.productId = productId;

    }

    public String toString(){

       return "产品编号="+this.productId+",产品名称="+this.name;

    }

    public ProductPrototype cloneProduct() {

       //创建一个新的订单,然后把本实例的数据复制过去

       Product product = new Product();

       product.setProductId(this.productId);

       product.setName(this.name);    

       return product;

    }

}

(2)订单的具体实现上也需要改变一下,需要在其属性上添加一个产品类型的属性,然后也需要实现克隆方法,示例代码如下:

public class PersonalOrder implements OrderApi{

    private String customerName;

private int orderProductNum = 0;

    /**

     * 产品对象

     */

    private Product product = null;

    public int getOrderProductNum() {

       return this.orderProductNum;

    }  

    public void setOrderProductNum(int num) {

       this.orderProductNum = num;

    }  

    public String getCustomerName() {

       return customerName;

    }

    public void setCustomerName(String customerName) {

       this.customerName = customerName;

    }

    public Product getProduct() {

       return product;

    }

    public void setProduct(Product product) {

       this.product = product;

    }  

    public String toString(){

       //简单点输出

       return "订购产品是="+this.product.getName()

+",订购数量为="+this.orderProductNum;

    }

    public OrderApi cloneOrder() {

       //创建一个新的订单,然后把本实例的数据复制过去

       PersonalOrder order = new PersonalOrder();

       order.setCustomerName(this.customerName);

       order.setOrderProductNum(this.orderProductNum);

       //对于对象类型的数据,深度克隆的时候需要继续调用这个对象的克隆方法

       order.setProduct((Product)this.product.cloneProduct());

       return order;

    }

 

 

}

(3)写个客户端来测试看看,是否深度克隆成功,示例代码如下:

public class Client {

    public static void main(String[] args) {

       //先创建原型实例

       PersonalOrder oa1 = new PersonalOrder();

       //设置原型实例的值

       Product product = new Product();

       product.setName("产品1");

       oa1.setProduct(product);

       oa1.setOrderProductNum(100);

      

        System.out.println("这是第一次获取的对象实例="+oa1);

       

       //通过克隆来获取新的实例

        PersonalOrder oa2 = (PersonalOrder)oa1.cloneOrder();

       //修改它的值

        oa2.getProduct().setName("产品2");

       oa2.setOrderProductNum(80);

       //输出克隆出来的对象的值

       System.out.println("输出克隆出来的实例="+oa2);

      

       //再次输出原型实例的值

       System.out.println("再次输出原型实例="+oa1);

    }

}

(4)运行结果如下,很明显,我们自己做的深度克隆是成功的:

这是第一次获取的对象实例=订购产品是=产品1,订购数量为=100

输出克隆出来的实例=订购产品是=产品2,订购数量为=80

再次输出原型实例=订购产品是=产品1,订购数量为=100

(5)小结

看来自己实现深度克隆也不是很复杂,但是比较麻烦,如果产品类里面又有属性是引用类型的话,在产品类实现克隆方法的时候,又需要调用那个引用类型的克隆方法了,这样一层一层调下去,如果中途有任何一个对象没有正确实现深度克隆,那将会引起错误,这也是深度克隆容易出错的原因。

2:Java中的深度克隆

利用Java中的clone方法来实现深度克隆,大体上和自己做差不多,但是也有一些需要注意的地方,一起看看吧。

(1)产品类没有太大的不同,主要是把实现的接口变成了Cloneable,这样一来,实现克隆的方法就不是cloneProduct,而是变成clone方法了;另外一个是克隆方法的实现变成了使用“super.clone();”了,示例代码如下:

public class Product implements Cloneable{

    private String productId;  

    private String name;

    public String getName() {

       return name;

    }

    public void setName(String name) {

       this.name = name;

    }

    public String getProductId() {

       return productId;

    }

    public void setProductId(String productId) {

       this.productId = productId;

    }

    public String toString(){

       return "产品编号="+this.productId+",产品名称="+this.name;

    }

    public Object clone() {

       Object obj = null;

       try {

           obj = super.clone();

       } catch (CloneNotSupportedException e) {

           e.printStackTrace();

       }

       return obj;

    }  

}

(2)具体的订单实现类,除了改变接口外,更重要的是在实现clone方法的时候,除了调用“super.clone();”外,必须显示的调用引用类型属性的clone方法,也就是产品的clone方法,示例代码如下:

public class PersonalOrder implements Cloneable , OrderApi{

    private String customerName;

    private Product product = null;

    private int orderProductNum = 0;  

    public int getOrderProductNum() {

       return this.orderProductNum;

    }  

    public void setOrderProductNum(int num) {

       this.orderProductNum = num;

    }  

    public String getCustomerName() {

       return customerName;

    }

    public void setCustomerName(String customerName) {

       this.customerName = customerName;

    }

    public Product getProduct() {

       return product;

    }

    public void setProduct(Product product) {

       this.product = product;

    }  

    public String toString(){

       //简单点输出

       return "订购产品是="+this.product.getName()

+",订购数量为="+this.orderProductNum;

    }

    public Object clone(){

       PersonalOrder obj=null;

       try {

           obj =(PersonalOrder)super.clone();

           //下面这一句话不可少

           obj.setProduct(

(Product)this.product.clone());

       } catch (CloneNotSupportedException e) {

           e.printStackTrace();

       }     

       return obj;

    }

}

(3)特别强调:

不可缺少“obj.setProduct((Product)this.product.clone());”这句话。为什么呢?

原因在于调用super.clone()方法的时候,Java是先开辟一块内存的空间,然后把实例对象的值原样拷贝过去,对于基本数据类型这样做是没有问题的,而属性product是一个引用类型,把值拷贝过去的意思就是把对应的内存地址拷贝过去了,也就是说克隆后的对象实例的product和原型对象实例的product指向的是同一块内存空间,是同一个产品实例。

       因此要想正确的执行深度拷贝,必须手工的对每一个引用类型的属性进行克隆,并重新设置,覆盖掉super.clone()所拷贝的值。

(4)客户端测试类跟刚才自己做的深度拷贝差不多,只是调用克隆的方法,原来是调用的cloneOrder方法,现在变成调用clone()。运行测试看看,运行结果如下:

这是第一次获取的对象实例=订购产品是=产品1,订购数量为=100

输出克隆出来的实例=订购产品是=产品2,订购数量为=80

再次输出原型实例=订购产品是=产品1,订购数量为=100

注意观察上面的数据,很明显这是正确的,修改克隆出来的实例的属性值,不会影响到原对象实例的属性的值。

(5)下面去掉“obj.setProduct((Product)this.product.clone());”这句话,看看会发生什么,运行结果如下:

这是第一次获取的对象实例=订购产品是=产品1,订购数量为=100

输出克隆出来的实例=订购产品是=产品2,订购数量为=80

再次输出原型实例=订购产品是=产品2,订购数量为=100

仔细观察一下,尤其是加粗的两行,你就会发现,修改克隆对象实例的产品名称属性的值,影响了原型对象实例的值,这说明没有正确深度克隆。

9.3.4  原型管理器

       如果一个系统中原型的数目不固定,比如系统中的原型可以被动态的创建和销毁,那么就需要在系统中维护一个当前可用的原型的注册表,这个注册表就被称为原型管理器。

       其实如果把原型当成一个资源的话,原型管理器就相当于一个资源管理器,在系统开始运行的时候初始化,然后运行期间可以动态的添加资源和销毁资源。从这个角度看,原型管理器就可以相当于一个缓存资源的实现,只不过里面缓存和管理的是原型实例而已。

       有了原型管理器过后,一般情况下,除了向原型管理器里面添加原型对象的时候是通过new来创造的对象,其余时候都是通过向原型管理器来请求原型实例,然后通过克隆方法来获取新的对象实例,这就可以实现动态管理、或者动态切换具体的实现对象实例。

       还是通过示例来说明,如何实现原型管理器。

(1)先定义原型的接口,非常简单,除了克隆方法,提供一个名称的属性,示例代码如下:

public interface Prototype {

    public Prototype clone();

    public String getName();

    public void setName(String name);

}

(2)再来看看两个具体的实现,实现方式基本上是一样的,分别看看。先看第一个原型的实现,示例代码如下:

public class ConcretePrototype1 implements Prototype {

    private String name;

    public String getName() {

       return name;

    }

    public void setName(String name) {

       this.name = name;

    }

    public Prototype clone() {

       ConcretePrototype1 prototype = new ConcretePrototype1();

       prototype.setName(this.name);

       return prototype;

    }

    public String toString(){

       return "Now in Prototype1,name="+name;

    }

}

       再看看第二个原型的实现,示例代码如下:

public class ConcretePrototype2 implements Prototype {

    private String name;

    public String getName() {

       return name;

    }

    public void setName(String name) {

       this.name = name;

    }

    public Prototype clone() {

       ConcretePrototype2 prototype = new ConcretePrototype2();

       prototype.setName(this.name);

       return prototype;

    }  

    public String toString(){

       return "Now in Prototype2,name="+name;

    }

}

(3)接下来看看原型管理器的实现示意,示例代码如下:

/**

 * 原型管理器

 */

public class PrototypeManager {

    /**

     * 用来记录原型的编号和原型实例的对应关系

     */

    private static Map<String,Prototype> map =

new HashMap<String,Prototype>();

    /**

     * 私有化构造方法,避免外部无谓的创建实例

     */

    private PrototypeManager(){

       //

    }

    /**

     * 向原型管理器里面添加或是修改某个原型注册

     * @param prototypeId 原型编号

     * @param prototype 原型实例

     */

    public synchronized static void setPrototype(

String prototypeId,Prototype prototype){

       map.put(prototypeId, prototype);

    }

    /**

     * 从原型管理器里面删除某个原型注册

     * @param prototypeId 原型编号

     */

    public synchronized static void removePrototype(

String prototypeId){

       map.remove(prototypeId);

    }

    /**

     * 获取某个原型编号对应的原型实例

     * @param prototypeId 原型编号

     * @return 原型编号对应的原型实例

     * @throws Exception 如果原型编号对应的原型实例不存在,报出例外

     */

    public synchronized static Prototype getPrototype(

String prototypeId)throws Exception{

       Prototype prototype = map.get(prototypeId);

       if(prototype == null){

           throw new Exception("您希望获取的原型还没有注册或已被销毁");

       }

       return prototype;

    }

}

       大家会发现,原型管理器是类似一个工具类的实现方式,而且对外的几个方法都是加了同步的,这主要是因为如果在多线程环境下使用这个原型管理器的话,那个map属性很明显就成了大家竞争的资源,因此需要加上同步。

(4)接下来看看客户端,如何使用这个原型管理器,示例代码如下:

public class Client {

    public static void main(String[] args) {

       try {

           // 初始化原型管理器

           Prototype p1 = new ConcretePrototype1();

           PrototypeManager.setPrototype("Prototype1", p1);

 

           // 获取原型来创建对象

           Prototype p3 = PrototypeManager

.getPrototype("Prototype1").clone();

           p3.setName("张三");

           System.out.println("第一个实例:" + p3);

 

           // 有人动态的切换了实现

           Prototype p2 = new ConcretePrototype2();

           PrototypeManager.setPrototype("Prototype1", p2);

 

           // 重新获取原型来创建对象

           Prototype p4 = PrototypeManager

.getPrototype("Prototype1").clone();

           p4.setName("李四");

           System.out.println("第二个实例:" + p4);

 

           // 有人注销了这个原型

           PrototypeManager.removePrototype("Prototype1");

 

           // 再次获取原型来创建对象

           Prototype p5 = PrototypeManager

.getPrototype("Prototype1").clone();

           p5.setName("王五");

           System.out.println("第三个实例:" + p5);

       } catch (Exception err) {

           System.err.println(err.getMessage());

       }

    }

}

运行一下,看看结果,结果示例如下:

第一个实例:Now in Prototype1,name=张三

第二个实例:Now in Prototype2,name=李四

您希望获取的原型还没有注册或已被销毁

9.3.5  原型模式的优缺点

l          对客户端隐藏具体的实现类型
    原型模式的客户端,只知道原型接口的类型,并不知道具体的实现类型,从而减少了客户端对这些具体实现类型的依赖。

l          在运行时动态改变具体的实现类型
    原型模式可以在运行期间,由客户来注册符合原型接口的实现类型,也可以动态的改变具体的实现类型,看起来接口没有任何变化,但其实运行的已经是另外一个类实例了。因为克隆一个原型就类似于实例化一个类。

l          深度克隆方法实现会比较困难
    原型模式最大的缺点就在于每个原型的子类都必须实现clone的操作,尤其在包含引用类型的对象时,clone方法会比较麻烦,必须要能够递归的让所有的相关对象都要正确的实现克隆。

9.3.6  思考原型模式

1:原型模式的本质

原型模式的本质:克隆生成对象

克隆是手段,目的还是生成新的对象实例。正是因为原型的目的是为了生成新的对象实例,原型模式通常是被归类为创建型的模式。

原型模式也可以用来解决“只知接口而不知实现的问题”,使用原型模式,可以出现一种独特的“接口造接口”的景象,这在面向接口编程中很有用。同样的功能也可以考虑使用工厂来实现。

另外,原型模式的重心还是在创建新的对象实例,至于创建出来的对象,其属性的值是否一定要和原型对象属性的值完全一样,这个并没有强制规定,只不过在目前大多数实现中,克隆出来的对象和原型对象的属性值是一样的。

也就是说,可以通过克隆来创造值不一样的实例,但是对象类型必须一样。可以有部分甚至是全部的属性的值不一样,可以有选择性的克隆,就当是标准原型模式的一个变形使用吧。

2:何时选用原型模式

建议在如下情况中,选用原型模式:

  • 如果一个系统想要独立于它想要使用的对象时,可以使用原型模式,让系统只面向接口编程,在系统需要新的对象的时候,可以通过克隆原型来得到
  • 如果需要实例化的类是在运行时刻动态指定时,可以使用原型模式,通过克隆原型来得到需要的实例

9.3.7  相关模式

l          原型模式和抽象工厂模式
   
功能上有些相似,都是用来获取一个新的对象实例的。
    不同之处在于,原型模式的着眼点是在如何创造出实例对象来,最后选择的方案是通过克隆;而抽象工厂模式的着眼点则在于如何来创造产品簇,至于具体如何创建出产品簇中的每个对象实例,抽象工厂模式不是很关注。
    正是因为它们的关注点不一样,所以它们也可以配合使用,比如在抽象工厂模式里面,具体创建每一种产品的时候就可以使用该种产品的原型,也就是抽象工厂管产品簇,具体的每种产品怎么创建则可以选择原型模式。

l          原型模式和生成器模式
   
这两种模式可以配合使用。
    生成器模式关注的是构建的过程,而在构建的过程中,很可能需要某个部件的实例,那么很自然地就可以应用上原型模式,通过原型模式来得到部件的实例。

 


---------------------------------------------------------------------------

私塾在线学习网原创内容  跟着cc学设计系列 之 研磨设计模式

原创内容,转载请注明出处【http://sishuok.com/forum/blogPost/list/0/5098.html

---------------------------------------------------------------------------



相关笔记推荐
精品视频课程推荐

研磨设计模式——跟着cc学设计系列视频教程
本视频课程是北京Java私塾原创精品书籍《研磨设计模式》一书的配套学习视频,由《研磨设计模式》的第一作者CC录制 课程目标:全面、系统的掌握GoF设计模式的知识,达到可以在实际项目开发中运用的能力 技术要点:如何实现可配置、如何实现缓存以及缓存的管理、如何实现用缓存来控制多实例的创建、如何实现参数化工厂、 如何实现可扩展工厂、如何实现原型管理器、如何实现Java的静态代理和动态代理、如何实现多线程处理队列请求、 如何实现命令的参数化配置、可撤销的操作、宏命令、队列请求和日志请求、如何实现翻页迭代、如何检测环状结构、 如何实现通用的增删改查、如何模拟工作流来处理流程、如何实现简单又通用的XML读取、如何实现模拟AOP的功能......

《设计模式综合项目实战》——跟着cc学设计系列精品视频教程

深入浅出学Shrio视频教程
内容概述:Shiro是目前最热门、最易用、功能超强大的Java权限管理框架,强烈推荐,每个项目都必备的权限管理技术!通过本课程,你将从零开始直到彻底掌握Shiro的相关开发知识,达到可以进行实际项目开发的能力。包括:权限管理基础、Shiro入门、配置、身份认证、授权、Realms、Session管理、和Spring的集成、Web、Cache等众多开发细节技术 技术要点:源码级分析Shiro的授权过程、自定义开发Realm、多个Realms的开发配置、自定义开发AuthenticationStrategy、自定义开发自定义SessionDAO、和Struts2+Spring3的集成(包括修正struts2的bug)、Shiro和SpringMVC+Spring3的集成、包装使用其他的Cache框架、缓存数据同步更新的解决方案等等实际开发中常用的内容

Javascript基础视频教程
JavaScript的内置对象--Array、String、Date、Math等,可以通过DOM对象进行对象控制,创建控制菜单及复选框的控制,创建二级联动列表框及列表框选项的移动,JavaScript项目,创建基于JS的商品管理系统。

XML基础视频教程
创建规范的XML文档,DTD的作用,并且可以根据要求创建私用的DTD,通过JavaScript解析XML DOM

浏览(6323)|评论(1)   交流分类:Java|笔记分类: 研磨设计模式

评论(1)
1楼 seekbug  2013-01-16 引用

已阅。

深度克隆也可以选择用Serializable。

请登录后评论 登录

关于我们 | 联系我们 | 用户协议 | 私塾在线服务协议 | 版权声明 | 隐私保护

版权所有 Copyright(C)2009-2012 私塾在线学习网