javaCrazer
javaCrazer

java序列化，深度解析

对象序列化是什么？

java程序启动会启动一个相应的jvm进程，在程序运行期间，若新生成了对象，则会在jvm堆上分配空间(大多数情况)，进行对象的表示，即对象的生命周期是短于jvm的，对象只能存在jvm进程运行时，但在某些情况下，我们希望将内存中的对象状态(即对象的实例数据)保存起来，保存的地方可能是文件，可能是数据库，然后在将来的某一个时间读取保存的"对象"(此时是二进制数据的对象)，将其恢复成内存中的对象。java的序列化机制即提供了这样一种功能，可以将内存中的对象转化为字节，字节可用于持久化保存，也可以进行远程传输(例如可以一台windows机器通过序列化将对象传输到另一台远端的linux机器)。反序列化自然就是将字节转化为内存中的对象。

如何使用？

若需要类支持序列化功能，只需实现java.io.Serializable 接口即可。该接口是一个标记接口，不含有任何方法。此处创建一个支持序列化功能的类Person，供后面讲解。

package demo;
import java.io.Serializable;
public class Person implements Serializable {
    
    private static final long serialVersionUID = -7763700527072968555L;
    private String name;
    private Integer age;
    private double height;

    public Person(String name, Integer age,double height) {
        System.out.println("Person的有参构造器");
        this.name = name;
        this.age = age;
        this.height=height;
    }

    public Person() {
        System.out.println("Person无参构造器");
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public Integer getAge() {
        return age;
    }

    public void setAge(Integer age) {
        this.age = age;
    }

    public double getHeight() {
        return height;
    }

    public void setHeight(double height) {
        this.height = height;
    }

    @Override
    public String toString() {
        return "Person{" +
                "name='" + name + '\'' +
                ", age=" + age +
                ", height=" + height +
                '}';
    }
}

测试类将可序列化的类保存到文件中

package demo;
import java.io.*;
class PersonTest {
    public static void main(String[] args) throws Exception {
        String filePath="C:\\test\\person.out";
        Person person = new Person("zhangsan", 21,1.80);
        ObjectOutputStream outputStream = new ObjectOutputStream(new FileOutputStream(filePath));
        //将对象序列化保存到文件中
        outputStream.writeObject(person);
        outputStream.close();
        //将文件中的字节还原为内存中的对象(反序列化)
        ObjectInputStream inputStream = new ObjectInputStream(new FileInputStream(filePath));
        Person readObject = (Person) inputStream.readObject();
        inputStream.close();
        System.out.println(readObject);
    }

}

测试结果为

Person的有参构造器
Person{name='zhangsan', age=21, height=1.8}

从输出结果可以知道两点：1.Serializable实现类反序列化的时候不会调用类的构造器，会直接根据保存的字节序列还原成内存中的对象。 2.引用类型数据和基础类型数据均可以序列化

默认的序列化机制

若对象里面也引用了其他对象，则默认的序列化机制会递归序列化，直到所有的对象都被序列化。(被引用的对象也需要支持序列化，否则不能被序列化，会抛出NotSerializableException异常)。增加Address类，并在前面的Person类中增加Address类

package demo;
import java.io.Serializable;
public class Address implements Serializable {
    
    private static final long serialVersionUID = 8670510229642968881L;
    private String province;
    private String city;
    private String county;
    
    public Address(String province, String city, String county) {
        this.province = province;
        this.city = city;
        this.county = county;
    }

    public String getProvince() {
        return province;
    }

    public void setProvince(String province) {
        this.province = province;
    }

    public String getCity() {
        return city;
    }

    public void setCity(String city) {
        this.city = city;
    }

    public String getCounty() {
        return county;
    }

    public void setCounty(String county) {
        this.county = county;
    }

    @Override
    public String toString() {
        return "Address{" +
                "province='" + province + '\'' +
                ", city='" + city + '\'' +
                ", county='" + county + '\'' +
                '}';
    }
}

修改Person类

package demo;
import java.io.Serializable;
public class Person implements Serializable {
    private static final long serialVersionUID = -7763700527072968555L;
    private String name;
    private Integer age;
    private double height;
    private Address address;
   //重点贴出修改的局部代码，其他保持不变

修改测试程序PersonTest.java

package demo;
import java.io.*;
class PersonTest {
    public static void main(String[] args) throws Exception {
        String filePath="C:\\test\\person.out";
        Address address = new Address("四川", "成都", "蒲江县");
        Person person = new Person("zhangsan", 21,1.80,address);
        ObjectOutputStream outputStream = new ObjectOutputStream(new FileOutputStream(filePath));
        //将对象序列化保存到文件中
        outputStream.writeObject(person);
        outputStream.close();
        //将文件中的字节还原为内存中的对象(反序列化)
        ObjectInputStream inputStream = new ObjectInputStream(new FileInputStream(filePath));
        Person readObject = (Person) inputStream.readObject();
        inputStream.close();
        System.out.println(readObject);
    }
}

运行测试程序，结果如下

Person的有参构造器
Person{name='zhangsan', age=21, height=1.8, address=Address{province='四川', city='成都', county='蒲江县'}}

控制序列化

  1. 对象中的字段可能因为某些原因，只需要序列化部分字段，例如，密码等字段由于安全原因不需要序列化，此时可以用transient关键字修饰不需要序列化的字段。修改前面的Person类
package demo;
import java.io.Serializable;
public class Person implements Serializable {
    private static final long serialVersionUID = -7763700527072968555L;
    private  String name;
    private transient Integer age;
    private transient double height;
    private transient Address address;   
    //重点贴出修改的局部代码，其他保持不变

运行测试程序，结果如下：

Person的有参构造器
Person{name='zhangsan', age=null, height=0.0, address=null}

可以观察到age，height，address字段没有被序列化保存到文件中，输出的值是均为其对应类型的默认值，并且transient关键字可以用在任何类型

  1. 精确控制序列化过程 Externalizable接口，其为Serializable的子接口，提供writeExternal(ObjectOutput out)控制序列化，readExternal(ObjectInput in)控制反序列化。修改Person类使其同时实现两个接口Serializable和Externalizable
package demo;

import java.io.*;

public class Person implements Externalizable, Serializable {


    private static final long serialVersionUID = -7763700527072968555L;
    private  String name;
    private  Integer age;
    private  double height;
    private  Address address;

    public Person(String name, Integer age,double height,Address address) {
        System.out.println("Person的有参构造器");
        this.name = name;
        this.age = age;
        this.height=height;
        this.address=address;
    }

    public Person() {
    }
  //省略setter和getter方法  

    public void writeExternal(ObjectOutput out) throws IOException {
        //暂时没有实现
    }

    public void readExternal(ObjectInput in) throws IOException, ClassNotFoundException {
       //暂时没有实现
    }
}

运行测试程序，结果如下：

Person的有参构造器
Person{name='null', age=null, height=0.0, address=null}

结果可以看到Person对象在实现Externalizable接口没有反序列化成功，可以猜测若同时实现Externalizable和Serializable接口，以Externalizable接口为准

重新修改Person对象，并添加必要的用于测试的方法，贴出修改部分

package demo;
import java.io.*;
public class Person implements Externalizable {
    private String name;
    private Integer age;
    private double height;
    private Address address;

    public Person(String name, Integer age, double height, Address address) {      
        this.name = name;
        this.age = age;
        this.height = height;
        this.address = address;
    }
    
    public Person() {
        System.out.println("Person的无参构造器");
    }

    public void writeExternal(ObjectOutput out) throws IOException {
        //手动控制序列化过程
        out.writeObject(name);
        out.writeObject(age);
        out.writeDouble(height);
        out.writeObject(address);

    }

    public void readExternal(ObjectInput in) throws IOException, ClassNotFoundException {
        //序列化字段顺序需要和反序列化字段顺序一致
        name = ((String) in.readObject());
        age = ((Integer) in.readObject());
        height = in.readDouble();
        address = ((Address) in.readObject());
    }
}

运行测试程序，结果如下：

Person的无参构造器
Person{name='zhangsan', age=21, height=1.8, address=Address{province='四川', city='成都', county='蒲江县'}}

从结果得出：1. 对象序列化和反序列化成功。2. Externalizable接口实现类对象在反序列化过程中会调用无参构造器

修改Person对象序列化和反序列化方法，使其顺序不对应

  public void writeExternal(ObjectOutput out) throws IOException {
        //手动控制序列化过程
        out.writeObject(name);
        out.writeObject(age);
        out.writeDouble(height);
        out.writeObject(address);
    }

    public void readExternal(ObjectInput in) throws IOException, ClassNotFoundException {
        //手动控制反序列化过程
        name = ((String) in.readObject());
        age = ((Integer) in.readObject());
        address = ((Address) in.readObject());  //此处的address字段和height字段没有对应
        height = in.readDouble();

    }

运行测试程序，结果如下：

Person的无参构造器
Exception in thread "main" java.io.OptionalDataException
    at java.io.ObjectInputStream.readObject0(ObjectInputStream.java:1365)
    at java.io.ObjectInputStream.readObject(ObjectInputStream.java:373)
    at demo.Person.readExternal(Person.java:81)
    at java.io.ObjectInputStream.readExternalData(ObjectInputStream.java:1849)
    at java.io.ObjectInputStream.readOrdinaryObject(ObjectInputStream.java:1806)
    at java.io.ObjectInputStream.readObject0(ObjectInputStream.java:1353)
    at java.io.ObjectInputStream.readObject(ObjectInputStream.java:373)
    at demo.PersonTest.main(PersonTest.java:16)

从结果得出：1. Externalizable接口实现类对象反序列化过程首先是调用Person类的无参构造器，然后再根据保存的二进制数据还原成内存中的对象。2.序列化过程字段的顺序和反序列化过程字段顺序需要保持一致，否则会抛出异常

Externalizable接口实现类在序列化过程中，只序列化部分字段，可以实现transient关键字的效果，当然也需要保持序列化和反序列化过程字段顺序一致

对比Externalizable和Serializable接口可知：1. Serializable接口反序列化过程不会调用无参构造器，完全以二进制数据恢复对象。2.Externalizable会调用无参构造器，然后以将二进制的数据放入到生成的对象中

  1. 通过在Serializable接口中添加特定方法实现序列化和反序列化控制，修改Person类如下：

    package demo;
import java.io.*;
public class Person implements Serializable {
    
   private static final long serialVersionUID = -7763700527072968555L;
    private String name;
    private Integer age;
    private double height;
    private transient Address address;//address属性此时不能被序列化

    public Person(String name, Integer age, double height, Address address) {
        this.name = name;
        this.age = age;
        this.height = height;
        this.address = address;
    }
    public Person() {
        System.out.println("Person的无参构造器");
    }
    
   //添加的方法必须为这个签名
    private void writeObject(ObjectOutputStream stream)
            throws IOException {
        stream.defaultWriteObject();//执行默认的递归序列化机制，不会序列化address属性
        stream.writeObject(address);//显示将transient关键字标记的字段序列化
    }
 //添加的方法必须为这个签名
    private void readObject(ObjectInputStream stream)
            throws IOException, ClassNotFoundException {
        stream.defaultReadObject();
        address = (Address) stream.readObject();//显示将transient关键字标记的字段反序列化并赋值到相应的属性
    }
}

    运行测试程序，结果如下：

    Person{name='zhangsan', age=21, height=1.8, address=Address{province='四川', city='成都', county='蒲江县'}}

    结果可以看到：1. 添加的方法在序列化和反序列化过程中会自动调用。2. 显示序列化的优先级高于transient关键字的优先级

    注意观察添加的两个方法，均是私有的private，按照开发习惯，通常这种标准的方法应该添加在接口中，但因为接口中的方法必须是public的，因此这两个方法不能添加到接口，在添加方法的时候要严格按照签名添加。此外，方法定义为private，意味着方法只能在类的内部调用，可是Person类中并没有调用，实际上Person类的writeObject调用是由java.io.ObjectStreamClass对象使用反射调用的

     void invokeWriteObject(Object obj, ObjectOutputStream out)
        throws IOException, UnsupportedOperationException
    {
        requireInitialized();
        if (writeObjectMethod != null) {
            try {
                writeObjectMethod.invoke(obj, new Object[]{ out }); //此处通过反射调用对象的writeObject方法
            } catch (InvocationTargetException ex) {
                Throwable th = ex.getTargetException();
                if (th instanceof IOException) {
                    throw (IOException) th;
                } else {
                    throwMiscException(th);
                }
            } catch (IllegalAccessException ex) {               
                throw new InternalError(ex);
            }
        } else {
            throw new UnsupportedOperationException();
        }
    }

    writeObjectMethod则是在ObjectStreamClass对象的构造器中初始化：

    if (externalizable) {
    cons = getExternalizableConstructor(cl);
} else {
    cons = getSerializableConstructor(cl);
    writeObjectMethod = getPrivateMethod(cl, "writeObject",
                                         new Class[] { ObjectOutputStream.class },
                                         Void.TYPE); //此处通过反射获取writeObject方法对象,cl即为添加了writeObject方法的类的Class对象
    readObjectMethod = getPrivateMethod(cl, "readObject",
                                        new Class[] { ObjectInputStream.class },
                                        Void.TYPE); //此处通过反射获取readObject方法对象,cl即为添加了readObject方法的类的Class对象
    readObjectNoDataMethod = getPrivateMethod(
        cl, "readObjectNoData", null, Void.TYPE);
    hasWriteObjectData = (writeObjectMethod != null);
}

    ObjectStreamClass类是对可序列化类的描述，里面封装了一些描述属性，ObjectStreamClass对象的创建通过lookup方法

        private Class cl;   //序列化类的Class对象
    private String name;  //序列化类的名字
    private volatile Long suid;  //序列化类的serialVersionUID
    private boolean isProxy;   //序列化类是否是动态代理类
    private boolean isEnum;  //序列化类是否是枚举
    private boolean serializable;  //序列化类是否实现了Serializable接口
    private boolean externalizable; //序列化类是否实现了Externalizable接口
    private Constructor cons; //序列化适当的构造器，Serializable接口和Externalizable接口接口获取构造器的方式不同

序列化版本serialVersionUID

前面生成的Person类中存在一个静态字段serialVersionUID，用作序列化和反序列化的版本控制，只有版本相同时，才能将字节反序列化为内存中的对象，重新还原出对象的状态，若序列化字节中的serialVersionUID和类的serialVersionUID不一致，则会抛出异常。

serialVersionUID可以显示指定，如 private static final long serialVersionUID = 8623666669972053776L；也可以不用指定，那么就会根据Java(TM) Object Serialization Specification规定的类的信息生成相应的serialVersionUID，一般都会显示指定serialVersionUID ，因为不同的编译器实现计算的serialVersionUID可能不同，进而导致抛出InvalidClassException异常。

注释测试程序的反序列化部分，首先进行序列化

package demo;
import java.io.*;
class PersonTest {
    public static void main(String[] args) throws Exception {
        String filePath="C:\\test\\person.out";
        Address address = new Address("四川", "成都", "蒲江县");
        Person person = new Person("zhangsan", 21,1.80,address);
        ObjectOutputStream outputStream = new ObjectOutputStream(new FileOutputStream(filePath));
        //将对象序列化保存到文件中
        outputStream.writeObject(person);
        outputStream.close();
        //将文件中的字节还原为内存中的对象(反序列化)
//        ObjectInputStream inputStream = new ObjectInputStream(new FileInputStream(filePath));
//        Person readObject = (Person) inputStream.readObject();
//        inputStream.close();
//        System.out.println(readObject);
    }
}

修改Person类的serialVersionUID，使其版本加一

注释测试程序的序列化部分，进行反序列化

package demo;
import java.io.*;
class PersonTest {
    public static void main(String[] args) throws Exception {
        String filePath="C:\\test\\person.out";
//        Address address = new Address("四川", "成都", "蒲江县");
//        Person person = new Person("zhangsan", 21,1.80,address);
//        ObjectOutputStream outputStream = new ObjectOutputStream(new FileOutputStream(filePath));
//        //将对象序列化保存到文件中
//        outputStream.writeObject(person);
//        outputStream.close();
//        将文件中的字节还原为内存中的对象(反序列化)
        ObjectInputStream inputStream = new ObjectInputStream(new FileInputStream(filePath));
        Person readObject = (Person) inputStream.readObject();
        inputStream.close();
        System.out.println(readObject);
    }
}

运行测试程序，结果如下：

Exception in thread "main" java.io.InvalidClassException: demo.Person; local class incompatible: stream classdesc serialVersionUID = 8623666669972053776, local class serialVersionUID = 8623666669972053777
    at java.io.ObjectStreamClass.initNonProxy(ObjectStreamClass.java:616)
    at java.io.ObjectInputStream.readNonProxyDesc(ObjectInputStream.java:1630)
    at java.io.ObjectInputStream.readClassDesc(ObjectInputStream.java:1521)
    at java.io.ObjectInputStream.readOrdinaryObject(ObjectInputStream.java:1781)
    at java.io.ObjectInputStream.readObject0(ObjectInputStream.java:1353)
    at java.io.ObjectInputStream.readObject(ObjectInputStream.java:373)
    at demo.PersonTest.main(PersonTest.java:16)

结果可以看出：抛出了InvalidClassException异常，并且提示指出两个类的版本不兼容(incompatible)，同时给出了类的版本号

序列化的常常用在远程调用中，将本地的对象序列化为字节，并通过网络传输给远端的一个机器，远端的机器通过反序列化还原成内存中的对象，实现数据的传递。现在考虑本地机器和远程机器在serialVersionUID不变的情况下，增减字段对序列化和反序列化的影响，serialVersionUID不一致无法序列化，因此不考虑。本地和远程增减字段总共4中情况，假设+表示增加字段，-表示减少字段，没有符号则表示字段不变，字段增减修改Person类

  1. 本地+sex，远程 (表示本地增加sex字段，远程版本字段保持不变)：测试时先增加sex进行序列化，表示本地版本。然后删除sex进行反序列化，表示远程版本，测试结果如下：

    Person{name='zhangsan', age=21, height=1.8, address=Address{province='四川', city='成都', county='蒲江县'}}

    结果可以看出：序列化文件中多余的字段对反序列化没有影响，远程版本中没有相应的字段，自然没有字段值

  2. 本地，远程+sex：测试时，先进行序列化，表示本地版本，然后添加sex进行反序列化，表示远程版本

    Person{name='zhangsan', age=21, height=1.8, address=Address{province='四川', city='成都', county='蒲江县'}, sex='null'}

    结果可以看出：远程版本中多余的字段，由于序列化文件中没有相应的字段值，因此远程版本中的字段取其类型的默认值

  3. 本地-age，远程：测试时，先删除age并进行序列化，表示本地版本，然后增加age字段并进行反序列化，表示远程版本

    Person{name='zhangsan', age=null, height=1.8, address=Address{province='四川', city='成都', county='蒲江县'}}

    结果可以看出：由于本地序列化文件中缺少age字段，因此反序列化的类中age字段取默认值

  4. 本地，远程-age：测试时，先进行序列化，表示本地版本，然后删除age，进程反序列化，表示远程版本

    Person{name='zhangsan', height=1.8, address=Address{province='四川', city='成都', county='蒲江县'}}

    结果可以看出：由于远程版本缺少age字段，因此即使序列化文件中有age值，反序列化后的类中任然没有age字段值

    综上：1. 只要版本一致，增减字段对序列化和反序列化过程没有影响。2.反序列化过程不会强制要求属性个数一致，若反序列化时，字段少了，自然就没有相应是字段值，若反序列化时，字段多了，多余的字段会取默认值。

序列化使用注意事项

  1. 序列化保存的是对象的状态，因此静态变量不会被序列化，反序列自然也没有值。修改Person类，增加静态属性country

    package demo;
import java.io.*;
public class Person implements Serializable {
    private static final long serialVersionUID = 8623666669972053776L;

    public static String COUNTRY;
    private String name;
    private Integer age;
    private double height;
    private Address address;
 //省略未修改代码
}

    修改测试程序并序列化

    package demo;
import java.io.*;
class PersonTest {
    public static void main(String[] args) throws Exception {
        String filePath = "C:\\test\\person.out";
        Address address = new Address("四川", "成都", "蒲江县");
        Person person = new Person("zhangsan", 21, 1.80, address);
        Person.COUNTRY = "中国";   //赋值静态属性
        ObjectOutputStream outputStream = new ObjectOutputStream(new FileOutputStream(filePath));
        outputStream.writeObject(person);
        outputStream.close();
    }
}

    反序列化，结果如下：

    Person{name='zhangsan', age=21, height=1.8, country=null, address=Address{province='四川', city='成都', county='蒲江县'}}

    结果可以看出：country静态属性没有被序列化，取值为默认值

  2. 基本数据类型可以直接被序列化，引用类型数据需要实现Serializable或Externalizable接口，才能序列化

  3. 默认序列化机制会递归序列化，若对象还引用了其他对象，则其他对象也需要支持序列化，否则会抛出NotSerializableException，若不想序列化引用的对象，可以使用transient关键字

  4. 若一个类不支持序列化，但其父类支持序列化，则这个类也支持序列化。扩展Person类，增加Student类

    package demo;
public class Student extends Person {
    private String schoolName;
    private String grade;
 //省略setter,getter和toString方法
}

    增加测试程序StudentTest.java

    package demo;
import java.io.*;
class StudentTest {
    public static void main(String[] args) throws Exception {
        String filePath = "C:\\test\\student.out";
        Student student = new Student("七中", "高一");
        ObjectOutputStream outputStream = new ObjectOutputStream(new FileOutputStream(filePath));
        outputStream.writeObject(student);
        outputStream.close();

        ObjectInputStream inputStream = new ObjectInputStream(new FileInputStream(filePath));
        Person readObject = (Person) inputStream.readObject();
        inputStream.close();
        System.out.println(readObject);
    }
}

    测试结果如下：

    Person的无参构造器  
Student{schoolName='七中', grade='高一'}

    结果可以看出：1. 若父类实现了序列化接口，则这类可以序列化(其实就是父类具有了某项功能，子类可通过继承，拥有其功能)

  5. 若子类可以序列化，但父类不能序列化，子类是可以序列化的。(java中所有类的最顶层父类都是Object，Object类不能序列化，但是String实现了Serializable接口，可以序列化)子类拥有的功能不受到父类的影响。

  6. 单例类在默认反序列化的时候，会被破坏，导致多个实例。创建单例类Company

    package demo;
public class Compony implements Serializable{
    private static final long serialVersionUID = -7328519208950924476L;
    //饿汉式单例
    private static final Compony COMPONY = new Compony();
    private Compony() {
        //防止在类的外面new对象
        System.out.println("Compony的私有构造器");
    }
    //通过该静态方法对外暴露该类的唯一实例
    public static Compony getInstance() {
        return COMPONY;
    }
}

    增加测试程序，测试反序列化后得到的Compony类是不是单例

    package demo;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
class ComponyTest {
    public static void main(String[] args) throws Exception {
        String filePath = "C:\\test\\compony.out";
        Compony compony = Compony.getInstance();
        ObjectOutputStream outputStream = new ObjectOutputStream(new FileOutputStream(filePath));
        outputStream.writeObject(compony);
        outputStream.close();

        ObjectInputStream inputStream = new ObjectInputStream(new FileInputStream(filePath));
        Compony readObject = (Compony) inputStream.readObject();
        inputStream.close();
        System.out.println("Compony是否是单例类：" + (readObject == Compony.getInstance()));
    }
}

    运行测试，结果如下：

    Compony是否是单例类：false

    从结果可以看出：1. 单例类在反序列化后被破坏，生成了一个新的对象。由于反序列化过程中会使用ObjectInputStream的readObject方法，因此从此方法追踪

    try {
    Object obj = readObject0(false);//生成对象
   //去除无关代码
    return obj;
} finally {
    passHandle = outerHandle;
    if (closed && depth == 0) {
        clear();
    }
        }

    继续追踪：

       ObjectStreamClass desc = readClassDesc(false);
        desc.checkDeserialize(); //此时的desc对象即是对序列化类的描述对象

        Object obj;
        try {
            obj = desc.isInstantiable() ? desc.newInstance() : null;  //此处通过反射创建对象
        } catch (Exception ex) {
            throw (IOException) new InvalidClassException(
                desc.forClass().getName(),
                "unable to create instance").initCause(ex);
        }

    继续向下：

    Object newInstance()
        throws InstantiationException, InvocationTargetException,
               UnsupportedOperationException
    {
     
        if (cons != null) {
            try {
                return cons.newInstance();   //此处便是核心的通过Constructor的newInstance反射创建对象
            } catch (IllegalAccessException ex) {
                // should not occur, as access checks have been suppressed
                throw new InternalError(ex);
            }
        } else {
            throw new UnsupportedOperationException();
        }
    }

    看到这里是否有疑问，Serializable实现类反序列化的时候不是不会调用构造器吗？怎么会通过构造器反射创建对象，实际代码输出也可以看出是没有调用无参构造器的，那此时这个cons是哪个的构造器呢？在此处断点调试
    seralizable1.png

可以看出此处的cons是Object的构造器，并不是Compony类的无参构造器

cons的初始化代码如下

//根据不同的接口实现类初始化cons
if (externalizable) {
    cons = getExternalizableConstructor(cl); 
} else {
    cons = getSerializableConstructor(cl);
   //去除无关代码    
}

综上：在反序列化的过程中，会调用cons.newInstance()生成一个新的对象，通过在序列化类中添加readResolve方法可以保证类的单例，修改Compony

package demo;
import java.io.Serializable;

public class Compony implements Serializable {
 //省略未修改部分代码
    
    private Object readResolve() {
        return COMPONY;//返回值作为反序列化的对象
    }
}

运行测试程序

Compony的私有构造器
Compony是否是单例类：true

结果可以看到：1. 单例类没有被破坏。观察Compony的readResolve方法也是私有的，类内部并没有调用，猜测也是在某处反射调用，入口依然是java.io.ObjectInputStream#readObject方法

if (obj != null &&
            handles.lookupException(passHandle) == null &&
            desc.hasReadResolveMethod())//若类实现了serializable or externalizable接口，且定义了readResolve方法，则返回true
        {
            Object rep = desc.invokeReadResolve(obj);  //此处反射调用readResolve方法
            if (unshared && rep.getClass().isArray()) {
                rep = cloneArray(rep);
            }
            if (rep != obj) {
                handles.setObject(passHandle, obj = rep);
            }
        }

继续向下追踪

 if (readResolveMethod != null) {
            try {
                return readResolveMethod.invoke(obj, (Object[]) null);//此处正真反射调用readResolve方法
            } catch (InvocationTargetException ex) {
               //去除无关代码
            } catch (IllegalAccessException ex) {              
                throw new InternalError(ex);
            }
        } else {
            throw new UnsupportedOperationException();
        }

readResolveMethod方法初始化代码：java.io.ObjectStreamClass#ObjectStreamClass(java.lang.Class)

if (externalizable) {
        cons = getExternalizableConstructor(cl);
    } else {
        cons = getSerializableConstructor(cl);
        writeObjectMethod = getPrivateMethod(cl, "writeObject",
                                             new Class[] { ObjectOutputStream.class },
                                             Void.TYPE);
        readObjectMethod = getPrivateMethod(cl, "readObject",
                                            new Class[] { ObjectInputStream.class },
                                            Void.TYPE);
        readObjectNoDataMethod = getPrivateMethod(
            cl, "readObjectNoData", null, Void.TYPE);
        hasWriteObjectData = (writeObjectMethod != null);
    }
    writeReplaceMethod = getInheritableMethod(
        cl, "writeReplace", null, Object.class);
    readResolveMethod = getInheritableMethod(
        cl, "readResolve", null, Object.class);//此处通过反射获取定义的readResolve方法
    return null;
                }

总结：单例类反序列化的时候需要注意单例类会被破坏，需要添加readResolve方法

你可能感兴趣的:(java序列化，深度解析)

  • 公众号流量主如何赚钱？深度解析流量变现之道 日常购物技巧呀
    微信公众号作为自媒体平台的重要一环，吸引了越来越多的内容创作者和商家。而公众号流量主作为平台上的重要角色，如何有效地将流量变现，成为许多运营者关注的焦点。那么，公众号流量主究竟如何赚钱呢？本文将深度解析流量变现的奥秘，为您揭示公众号流量主的赚钱之道。废掉一个孩子最快的方式，就让他待在家里，一天到晚待在家里公众号流量主就找善士导师（shanshi2024）公众号：「善士笔记」主理人，《我的亲身经历，
  • STM32的寄存器深度解析 千千道 STM32stm32单片机物联网
    目录一、STM32寄存器概述二、寄存器的定义与作用三、寄存器分类1.内核寄存器2.外设寄存器四、重要寄存器详解1.GPIO相关寄存器2.定时器相关寄存器3.中断相关寄存器4.RCC相关寄存器五、寄存器操作方法1.直接操作寄存器2.使用库函数操作寄存器六、总结在嵌入式系统开发中，STM32微控制器以其强大的性能和丰富的功能而备受青睐。而理解和掌握STM32的寄存器是深入学习和开发STM32的关键。本
  • 深度解析：如何使用输出解析器将大型语言模型（LLM）的响应解析为结构化JSON格式 m0_57781768 语言模型json人工智能
    深度解析：如何使用输出解析器将大型语言模型（LLM）的响应解析为结构化JSON格式在现代自然语言处理（NLP）的应用中，大型语言模型（LLM）已经成为了重要的工具。这些模型能够生成丰富的自然语言文本，适用于各种应用场景。然而，在某些应用中，开发者不仅仅需要生成文本，还需要将这些生成的文本转换为结构化的数据格式，例如JSON。这种结构化的数据格式在数据传输、存储以及进一步处理时具有显著优势。本文将深
  • 深度解析：云原生环境下Docker部署Doris数据库 N201871643 云原生docker数据库
    深度解析：云原生环境下Docker部署Doris数据库目录深度解析：云原生环境下Docker部署Doris数据库引言一、云原生与Docker基础1.云原生概念2.Docker简介二、Doris数据库概述1.Doris数据库特性2.Doris在云原生环境中的应用三、Docker部署Doris数据库1.准备环境2.编写Dockerfile3.使用DockerCompose部署Doris集群4.配置Do
  • Java 实体类转byte数组 亦诗亦诗 javajvm开发语言
    Java实体类转byte数组在Java中，将实体类转换为字节数组的常用方式是将其序列化为二进制数据。可以使用Java提供的序列化API或第三方库实现。1、下面是使用Java序列化API将实体类转换为字节数组的示例代码：1、实现java.io.Serializable接口publicclassMyClassimplementsSerializable{//...}2、创建一个ObjectOutput
  • 腾讯云技术深度解析：AI代码助手与微服务架构的实践应用 我的运维人生 架构腾讯云人工智能运维开发技术共享
    腾讯云技术深度解析：AI代码助手与微服务架构的实践应用在数字化转型的浪潮中，云计算作为关键基础设施，正深刻改变着企业的IT架构和业务模式。腾讯云，作为国内领先的云服务提供商，不仅在基础设施层面提供了强大的支持，还在AI、大数据、微服务等领域不断创新，为开发者提供了丰富的技术工具和解决方案。本文将深入探讨腾讯云AI代码助手在编程实践中的应用，并结合微服务架构的实例，展示腾讯云在提升开发效率和系统稳定
  • 淘宝返利app哪个最好 淘宝返利的软件有哪些app 高省APP
    淘宝返利app哪个最好淘宝返利的软件有哪些app在淘宝购物时，你是否曾想过通过返利软件来获得额外的优惠呢？现在市面上有很多淘宝返利app，其中高省和氧惠是备受推荐的两种。本文将为你深度解析高省和氧惠返利app，让你购物更划算！大家好，我是高省的波西导师。在开始本文的交流之前，我想向大家介绍一款网购省钱利器——高省APP，同时也是一项难得的零投入零成本的创业项目。官方邀请码088886，应用商店搜索
  • Redis 缓存深度解析：穿透、击穿、雪崩与预热的全面解读 加勒比海涛 Redis入门实践缓存redis数据库
    Redis缓存深度解析：穿透、击穿、雪崩与预热的全面解读一.什么是缓存?二.使用Redis作为缓存三.缓存的更新策略3.1定期生成3.2实时生成四.缓存预热、缓存穿透、缓存雪崩、缓存击穿4.1缓存预热4.2缓存穿透4.3缓存雪崩4.4缓存击穿Hello,大家好,这个专栏给大家带来的是Redis系列!本篇文章给大家讲解的是Redis的缓存.在Redis缓存系统中,缓存穿透、缓存击穿、缓存雪崩和缓存预
  • 计算机组成原理：总线技术深度解析 努力编程的阿伟 网络计算机组成
    目录1.总线技术概述1.1什么是总线？1.2总线的基本功能2.总线的类型2.1内部总线2.2外部总线3.总线的标准与协议3.1常见的总线标准3.2总线协议4.总线的性能考量4.1带宽4.2延迟4.3可扩展性5.总线的未来趋势6.结语在计算机科学的浩瀚宇宙中，总线技术扮演着至关重要的角色。它是连接计算机硬件组件的神经网络，负责协调数据、指令和电源的流动。今天，我们将深入探讨总线的概念、类型、标准以及
  • 《隐秘的角落》分集深度解析第五回（连载） Ricky的成长疗愈空间
    第五集妈妈第一幕：晶晶的葬礼结束后，王瑶在公安局质问办案人员为什么不去抓凶手朱朝阳，朱永平说朝阳出现在少年宫不能说明什么。王瑶找到朝阳试探他是否知道事情的细节，朝阳慌张露出马脚。王瑶追打朝阳时，周春红赶来导致了更激烈的纠缠。王瑶一口咬定朝阳妈妈是幕后主谋，两人都是杀人凶手。王瑶质问周春红当天在哪里，周春红无法回答，加深了她的怀疑。在邻居的阻拦下，王瑶只好离开，并说“我一定让你们两个偿命！”启发：当
  • java 接口创建对象 专注API从业者 经验分享电商平台API接口java开发语言大数据数据库数据挖掘
    Java接口创建对象：深度解析与示例在Java编程中，接口是一种非常重要的概念。它不仅为不同类之间的交互提供了规范，也促进了代码的重用和解耦。本文将深入探讨如何在Java中使用接口创建对象，带您理解这一关键特性。什么是接口？接口（Interface）是一种特殊的抽象类，定义了一组方法的声明，但不提供具体的实现。接口允许我们定义类的方法，而不需要指定它们是什么。这使得接口在Java中成为实现多态性、
  • 深度解析《完美陌生人》的另类结构 星期五文艺
    要探讨这部《完美陌生人》背后所暴露出的种种社会问题，首先我们得先把这部电影看懂。而看懂这部电影的关键之处有二：一是缕清它讲故事的总体结构。二是缕清它的人物（人设）结构。当你缕清这两个结构问题的时候，便会发现这部电影的厉害之处——无论是其完美的对称性，还是导演对电影娴熟的节奏把控，再或是电影“假戏真演”的技法所诱发的你的深度思考……都足以让我们学习借鉴了。接下来我们就从电影的结构来细看下这部电影——
  • WebKit 简介及工作流程深度解析 不知名靓仔 webkitchromesafariedge
    WebKit是一个开源的浏览器引擎，最初由苹果公司为Safari浏览器开发，后来被多个浏览器和应用采纳，如早期的Chrome和众多移动平台上的浏览器。WebKit不仅仅是一个渲染引擎，它集成了HTML、CSS、JavaScript的解析与渲染能力，以及网络资源加载、图形处理、排版布局等功能，为用户提供丰富的网页浏览体验。本文将深入探讨WebKit的核心组件以及其复杂的工作流程。WebKit核心架构
  • Python搭建自己的VPN 用数据说话用数据决策 pythonphp网络
    在这个信息爆炸的数字化时代，我们的网络隐私和安全正面临着前所未有的挑战。虚拟专用网络（VPN）作为一种有效的解决方案，通过加密通信和隧道技术，为用户在公共网络上提供安全的连接。本文将带您深入了解VPN的工作机制，并展示如何使用Python和strongSwan库构建一个高级VPN连接，以实现更高级别的安全性和灵活性。VPN工作机制深度解析加密通信协议：数据的保护神VPN的首要任务是确保数据的机密性
  • 【WebKit深度解析】HTML5支持全景与实践指南 2401_85812026 webkithtml5前端
    标题：【WebKit深度解析】HTML5支持全景与实践指南WebKit作为许多现代浏览器的核心技术，对HTML5的支持程度直接关系到Web应用的性能和体验。HTML5是构建现代Web应用的基石，提供了丰富的特性和API。本文将深入探讨WebKit对HTML5的支持程度，并通过实际代码示例，展示如何在WebKit浏览器上充分利用HTML5的强大功能。1.WebKit与HTML5概述WebKit是一个
  • 深度解析：从概念到变革——Transformer大模型的前世今生以及大模型预备知识讲解[知存科技] 汀、人工智能 LLM技术汇总transformer深度学习人工智能自然语言处理LLMattention机制编码器解码器
    深度解析：从概念到变革——Transformer大模型的前世今生点击：知存科技相关课程推荐知存科技是全球领先的存内计算芯片企业。针对AI应用场景，在全球率先商业化量产基于存内计算技术的神经网络芯片。凭借颠覆性的技术创新，知存科技突破传统计算架构局限，利用存储与计算的物理融合大幅减少数据搬运，在相同工艺条件下将AI计算效率提升2个数量级，充分满足快速发展的神经网络模型指数级增长的算力需求。相关链接推
  • Nginx部署前端Vue项目的深度解析 小周不想卷 #前端vue入门前端前端框架nginxvue.js
    目录一、准备工作1.1开发环境1.2服务器环境1.3Nginx安装二、构建Vue项目三、上传静态文件到服务器四、配置Nginx五、测试并重新加载Nginx六、访问Vue应用七、高级配置7.1启用HTTPS7.2启用Gzip压缩7.3缓存控制八、常见问题与解决方案8.1404错误8.2权限问题8.3跨域问题九、总结在现代Web开发中，Vue.js因其组件化、响应式数据绑定和易于上手的特点，成为了前端
  • 3.创建型设计模式详解：生成器模式与原型模式的深度解析 胡耀超 设计模式原型模式设计模式生成器模式创建型设计模式java后端
    设计模式（DesignPatterns）是软件开发中常用的解决方案，帮助开发者处理常见的设计问题。创建型设计模式专注于对象的实例化，旨在提高系统的灵活性和可维护性。在这篇文章中，我们将深入探讨创建型设计模式中的生成器模式（BuilderPattern）和原型模式（PrototypePattern），详细分析它们的应用场景、优缺点，并通过类图和综合案例加以对比。1.创建型设计模式概述创建型设计模式包
  • MySQL数据库运维：深度解析与实践指南 野老杂谈 数据库mysql运维
    欢迎来到我的博客，很高兴能够在这里和您见面！欢迎订阅相关专栏：+V:LAF20151116进行更多交流学习⭐️全网最全IT互联网公司面试宝典：收集整理全网各大IT互联网公司技术、项目、HR面试真题.⭐️AIGC时代的创新与未来：详细讲解AIGC的概念、核心技术、应用领域等内容。⭐️全流程数据技术实战指南：全面讲解从数据采集到数据可视化的整个过程，掌握构建现代化数据平台和数据仓库的核心技术和方法。⭐
  • 揭开数据可视化的神秘面纱：《Python数据可视化：科技图表绘制》深度解析 屿小夏 书籍推荐信息可视化python科技
    文章目录一、内容简介二、值得一读2.1全面覆盖Python基础与高级可视化技术2.2丰富的实践案例与操作示例2.3视频教学与配套资源文件2.4作者的专业背景与权威性三、适读人群3.1科研人员与工程师3.2数据分析师与从业者3.3大学生与研究生3.4零基础的编程爱好者四、配套资源与学习支持4.1公共数据集与示例代码4.2微信公众号支持与资源下载4.3常见问题与读者互动五、总结一、内容简介在大数据和人
  • 数仓还是湖仓？专家圆桌深度解析 StarRocks_labs 数据仓库数据库大数据数据分析湖仓一体
    近期，Databricks以超过10亿美元的价格收购了Tabular——ApacheIceberg的商业支持公司，这一动作加剧了Snowflake和Databricks在开放湖仓标准发展上的竞争。这起收购也突显了数据湖表格式在现代数据分析架构中的关键地位。在上月的StarRocksMeetup活动中，四位湖仓技术专家代表ApacheIceberg、ApacheHudi、ApachePaimon和S
  • 微软云技术深度解析与实战案例 我的运维人生 microsoftflaskpython运维开发技术共享
    微软云技术深度解析与实战案例在云计算的浪潮中，微软Azure凭借其强大的技术实力和丰富的服务种类，成为了众多企业和开发者首选的云服务平台。本文将从微软云服务的核心优势、关键技术、以及一个具体的代码使用案例出发，深入探讨如何在Azure平台上构建高效、可靠的应用程序。微软云服务的核心优势微软Azure作为全球领先的云服务平台，其优势主要体现在以下几个方面：广泛的服务种类：Azure提供了包括计算、存
  • 深入剖析 RabbitMQ：架构深度解析、原理细节与关键特性全面掌握 马丁的代码日记 开发语言后端
    摘要：本文深入探讨了RabbitMQ这一开源消息代理的各个方面，包括其架构设计、工作原理、关键特性如延迟消息、死信队列、高可用性、消费限流、去重策略、消息持久化和事务性操作等。旨在为开发者和架构师提供全面的RabbitMQ知识，以助其在分布式系统中有效利用该技术。关键词：RabbitMQ,消息队列,分布式系统,延迟消息,死信队列,高可用性,消费限流,消息持久化,事务性操作一、引言在当今复杂的分布式
  • 『深度解析』本金5千回血30万-精选文案 胡力
    我想帮助更多的人是认真的蹈失425.68.05，所以总结出来了一些经验，也是希望让更多的大家不要在误入歧途了。平台的重要性；如今平台众多，黑的、圈的、跑的多不胜数，更有甚者直接把你的收获以各种理由去掉！从此处可以看出平台的重要性显得尤其重要！心态的重要性；一旦心态奔溃，眼红失去理智，盲目无措，意味着必定错，能控制好自己、不急躁、不乱来、不凭感觉，才是你成的开始。娱乐心态，过分看重，劝你别玩了！技巧
  • Node.js 入门：中间件与安全性深度解析 Switch616 前端node.js中间件chrome服务器架构前端前端框架
    Node.js入门：中间件与安全性深度解析目录认证与授权使用jsonwebtoken实现JWT身份验证用户注册与登录：认证流程与实践️权限管理：安全访问控制详解️安全性防止SQL注入：参数化查询与ORM的最佳实践防止XSS攻击：用户输入处理与安全防护使用HTTPS和SSL/TLS：加密传输与数据安全⚠️错误处理️全局错误处理：确保应用稳定性的关键异常捕获与日志记录：有效排查问题的核心认证与授权使用
  • 探索Node.js内存的奥秘：node-mtrace深度解析与应用推荐 焦珑雯
    探索Node.js内存的奥秘：node-mtrace深度解析与应用推荐node-mtraceNativememoryallocationtracingandmtracelogparsingfornode.项目地址:https://gitcode.com/gh_mirrors/no/node-mtrace在Node.js的世界里，内存管理一直是一个关键而微妙的话题。开发者往往需要精准地掌握应用程序的
  • 深度解析react中hooks的底层原理是啥？React架构fiber原理深度解析 为了WLB努力 react.js
    1.ReactHooks底层原理ReactHooks的底层原理是基于ReactFiber架构的实现。下面是对ReactHooks底层原理的深度解析：Fiber架构：ReactFiber是React的新的协调引擎，它的设计目标是支持增量式更新、优先级调度、暂停和继续执行等特性。Fiber架构重新实现了React的调度算法，使得React可以更灵活地控制组件的渲染过程。我们都知道react框架的核心算
  • 深度解析构建 API 时常见的 10 种错误状态代码及应对策略 sjsdblog 服务器网络数据库API开发
    在首次构建API时，可能会遇到各种错误状态代码。这些错误代码可以帮助我们快速识别问题所在，并采取相应的解决措施。本文将介绍10个常见的错误状态代码，包括4XX客户端错误和5XX服务器端错误，并提供相应的解决方法。一、客户端错误1.404未找到当客户端请求的资源不存在时，会返回404错误。这可能是因为输入的URL错误、资源已被删除或移动等原因导致的。解决方法是检查输入的URL是否正确，确保资源存在且
  • 深度解析纯原和正品的区别，铭记两者的三个不同点 优鞋之家
    深度解析纯原和正品的区别，铭记两者的三个不同点纯原鞋是出类拔萃的象征，是工艺水平的代表，它楚楚不凡万人赏，丰标不凡世人追。还原度达到了最高临界值，工艺之高叹为观止，那么纯原和正品的区别是什么？纯原鞋可以过得物吗？关于纯原鞋的各个方面这次一普到底！详情咨询VX→wkk22999微信图片_20230223205412.jpg纯原鞋是什么意思?纯原鞋其实是仿鞋。真实的情况是代表莆田的一种顶级工艺，它是市
  • 海狐外卖O2O商城系统：技术架构与运营模式的深度解析 前端组件开发 架构开发语言uni-app低代码开源前端
    摘要：本文深入探讨了海狐外卖O2O商城系统的技术架构、功能特性以及运营模式。海狐外卖作为一款专注于细分市场领域的外卖餐饮解决方案，不仅拥有先进的技术栈支持，还通过丰富的系统插件和灵活的运营模式，为商户和用户提供高效、便捷的服务。本文将从技术角度对其架构进行详细解析，并探讨其运营模式和市场前景。一、引言随着互联网的快速发展，外卖行业迅速崛起，成为消费者日常生活中不可或缺的一部分。海狐外卖作为一款专注
  • 强大的销售团队背后 竟然是大数据分析的身影 蓝儿唯美 数据分析
    Mark Roberge是HubSpot的首席财务官，在招聘销售职位时使用了大量数据分析。但是科技并没有挤走直觉。 大家都知道数理学家实际上已经渗透到了各行各业。这些热衷数据的人们通过处理数据理解商业流程的各个方面，以重组弱点，增强优势。 Mark Roberge是美国HubSpot公司的首席财务官，HubSpot公司在构架集客营销现象方面出过一份力——因此他也是一位数理学家。他使用数据分析
  • Haproxy+Keepalived高可用双机单活 bylijinnan 负载均衡keepalivedhaproxy高可用
    我们的应用MyApp不支持集群，但要求双机单活（两台机器：master和slave）： 1.正常情况下，只有master启动MyApp并提供服务 2.当master发生故障时，slave自动启动本机的MyApp，同时虚拟IP漂移至slave，保持对外提供服务的IP和端口不变 F5据说也能满足上面的需求，但F5的通常用法都是双机双活，单活的话还没研究过 服务器资源 10.7
  • eclipse编辑器中文乱码问题解决 0624chenhong eclipse乱码
    使用Eclipse编辑文件经常出现中文乱码或者文件中有中文不能保存的问题，Eclipse提供了灵活的设置文件编码格式的选项，我们可以通过设置编码 格式解决乱码问题。在Eclipse可以从几个层面设置编码格式：Workspace、Project、Content Type、File 本文以Eclipse 3.3（英文）为例加以说明： 1. 设置Workspace的编码格式： Windows-&g
  • 基础篇--resources资源 不懂事的小屁孩 android
    最近一直在做java开发，偶尔敲点android代码，突然发现有些基础给忘记了，今天用半天时间温顾一下resources的资源。 String.xml    字符串资源   涉及国际化问题  http://www.2cto.com/kf/201302/190394.html   string-array
  • 接上篇补上window平台自动上传证书文件的批处理问卷 酷的飞上天空 window
    @echo off : host=服务器证书域名或ip，需要和部署时服务器的域名或ip一致 ou=公司名称, o=公司名称 set host=localhost set ou=localhost set o=localhost set password=123456 set validity=3650 set salias=s
  • 企业物联网大潮涌动：如何做好准备？ 蓝儿唯美 企业
    物联网的可能性也许是无限的。要找出架构师可以做好准备的领域然后利用日益连接的世界。 尽管物联网（IoT）还很新，企业架构师现在也应该为一个连接更加紧密的未来做好计划，而不是跟上闸门被打开后的集成挑战。“问题不在于物联网正在进入哪些领域，而是哪些地方物联网没有在企业推进，” Gartner研究总监Mike Walker说。 Gartner预测到2020年物联网设备安装量将达260亿，这些设备在全
  • spring学习——数据库（mybatis持久化框架配置） a-john mybatis
    Spring提供了一组数据访问框架，集成了多种数据访问技术。无论是JDBC，iBATIS(mybatis)还是Hibernate，Spring都能够帮助消除持久化代码中单调枯燥的数据访问逻辑。可以依赖Spring来处理底层的数据访问。 mybatis是一种Spring持久化框架，要使用mybatis，就要做好相应的配置： 1，配置数据源。有很多数据源可以选择，如：DBCP，JDBC，aliba
  • Java静态代理、动态代理实例 aijuans Java静态代理
    采用Java代理模式，代理类通过调用委托类对象的方法，来提供特定的服务。委托类需要实现一个业务接口，代理类返回委托类的实例接口对象。 按照代理类的创建时期，可以分为：静态代理和动态代理。 所谓静态代理：　指程序员创建好代理类，编译时直接生成代理类的字节码文件。 所谓动态代理：　在程序运行时，通过反射机制动态生成代理类。   一、静态代理类实例： 1、Serivce.ja
  • Struts1与Struts2的12点区别 asia007 Struts1与Struts2
    1) 在Action实现类方面的对比：Struts 1要求Action类继承一个抽象基类；Struts 1的一个具体问题是使用抽象类编程而不是接口。Struts 2 Action类可以实现一个Action接口，也可以实现其他接口，使可选和定制的服务成为可能。Struts 2提供一个ActionSupport基类去实现常用的接口。即使Action接口不是必须实现的，只有一个包含execute方法的P
  • 初学者要多看看帮助文档 不要用js来写Jquery的代码 百合不是茶 jqueryjs
    解析json数据的时候需要将解析的数据写到文本框中,  出现了用js来写Jquery代码的问题;   1, JQuery的赋值  有问题    代码如下: data.username 表示的是:  网易            $("#use
  • 经理怎么和员工搞好关系和信任 bijian1013 团队项目管理管理
            产品经理应该有坚实的专业基础，这里的基础包括产品方向和产品策略的把握，包括设计，也包括对技术的理解和见识，对运营和市场的敏感，以及良好的沟通和协作能力。换言之，既然是产品经理，整个产品的方方面面都应该能摸得出门道。这也不懂那也不懂，如何让人信服？如何让自己懂？就是不断学习，不仅仅从书本中，更从平时和各种角色的沟通
  • 如何为rich:tree不同类型节点设置右键菜单 sunjing contextMenutreeRichfaces
    组合使用target和targetSelector就可以啦，如下： <rich:tree id="ruleTree" value="#{treeAction.ruleTree}" var="node" nodeType="#{node.type}" selectionChangeListener=&qu
  • 【Redis二】Redis2.8.17搭建主从复制环境 bit1129 redis
    开始使用Redis2.8.17 Redis第一篇在Redis2.4.5上搭建主从复制环境，对它的主从复制的工作机制，真正的惊呆了。不知道Redis2.8.17的主从复制机制是怎样的，Redis到了2.4.5这个版本，主从复制还做成那样，Impossible is nothing! 本篇把主从复制环境再搭一遍看看效果，这次在Unbuntu上用官方支持的版本。   Ubuntu上安装Red
  • JSONObject转换JSON--将Date转换为指定格式 白糖_ JSONObject
    项目中，经常会用JSONObject插件将JavaBean或List<JavaBean>转换为JSON格式的字符串，而JavaBean的属性有时候会有java.util.Date这个类型的时间对象，这时JSONObject默认会将Date属性转换成这样的格式：   {"nanos":0,"time":-27076233600000,
  • JavaScript语言精粹读书笔记 braveCS JavaScript
    【经典用法】：   //①定义新方法 Function .prototype.method=function(name, func){ this.prototype[name]=func; return this; } //②给Object增加一个create方法，这个方法创建一个使用原对
  • 编程之美-找符合条件的整数 用字符串来表示大整数避免溢出 bylijinnan 编程之美
    import java.util.LinkedList; public class FindInteger { /** * 编程之美 找符合条件的整数 用字符串来表示大整数避免溢出 * 题目：任意给定一个正整数N，求一个最小的正整数M(M>1)，使得N*M的十进制表示形式里只含有1和0 * * 假设当前正在搜索由0，1组成的K位十进制数
  • 读书笔记 chengxuyuancsdn 读书笔记
    1、Struts访问资源 2、把静态参数传递给一个动作 3、<result>type属性 4、s:iterator、s:if c:forEach 5、StringBuilder和StringBuffer 6、spring配置拦截器 1、访问资源 (1)通过ServletActionContext对象和实现ServletContextAware,ServletReque
  • [通讯与电力]光网城市建设的一些问题 comsci 问题
          信号防护的问题,前面已经说过了,这里要说光网交换机与市电保障的关系       我们过去用的ADSL线路,因为是电话线,在小区和街道电力中断的情况下,只要在家里用笔记本电脑+蓄电池,连接ADSL,同样可以上网........     
  • oracle 空间RESUMABLE daizj oracle空间不足RESUMABLE错误挂起
    空间RESUMABLE操作  转 Oracle从9i开始引入这个功能，当出现空间不足等相关的错误时，Oracle可以不是马上返回错误信息，并回滚当前的操作，而是将操作挂起，直到挂起时间超过RESUMABLE TIMEOUT，或者空间不足的错误被解决。 这一篇简单介绍空间RESUMABLE的例子。 第一次碰到这个特性是在一次安装9i数据库的过程中，在利用D
  • 重构第一次写的线程池 dieslrae 线程池 python
    最近没有什么学习欲望,修改之前的线程池的计划一直搁置,这几天比较闲,还是做了一次重构,由之前的2个类拆分为现在的4个类. 1、首先是工作线程类:TaskThread,此类为一个工作线程,用于完成一个工作任务,提供等待(wait),继续(proceed),绑定任务(bindTask)等方法 #!/usr/bin/env python # -*- coding:utf8 -*-
  • C语言学习六指针 dcj3sjt126com c
    初识指针，简单示例程序： /* 指针就是地址，地址就是指针 地址就是内存单元的编号 指针变量是存放地址的变量 指针和指针变量是两个不同的概念 但是要注意： 通常我们叙述时会把指针变量简称为指针，实际它们含义并不一样 */ # include <stdio.h> int main(void) { int * p; // p是变量的名字， int *
  • yii2 beforeSave afterSave beforeDelete dcj3sjt126com delete
    public function afterSave($insert, $changedAttributes) { parent::afterSave($insert, $changedAttributes); if($insert) { //这里是新增数据 } else { //这里是更新数据 } }  
  • timertask shuizhaosi888 timertask
    java.util.Timer timer = new java.util.Timer(true); // true 说明这个timer以daemon方式运行（优先级低， // 程序结束timer也自动结束），注意，javax.swing // 包中也有一个Timer类，如果import中用到swing包， // 要注意名字的冲突。 TimerTask task = new
  • Spring Security（13）——session管理 234390216 sessionSpring Security攻击保护超时
    session管理 目录   1.1     检测session超时 1.2     concurrency-control 1.3     session 固定攻击保护         
  • 公司项目NODEJS实践0.3[ mongo / session ...] 逐行分析JS源代码 mongodbsessionnodejs
        http://www.upopen.cn   一、前言         书接上回，我们搭建了WEB服务端路由、模板等功能，完成了register 通过ajax与后端的通信，今天主要完成数据与mongodb的存取，实现注册 / 登录 /
  • pojo.vo.po.domain区别 LiaoJuncai javaVOPOJOjavabeandomain
    　　POJO = "Plain Old Java Object"，是MartinFowler等发明的一个术语，用来表示普通的Java对象，不是JavaBean, EntityBean 或者 SessionBean。POJO不但当任何特殊的角色，也不实现任何特殊的Java框架的接口如，EJB， JDBC等等。 　　 　　即POJO是一个简单的普通的Java对象，它包含业务逻辑
  • Windows Error Code OhMyCC windows
    0 操作成功完成. 1 功能错误. 2 系统找不到指定的文件. 3 系统找不到指定的路径. 4 系统无法打开文件. 5 拒绝访问. 6 句柄无效. 7 存储控制块被损坏. 8 存储空间不足, 无法处理此命令. 9 存储控制块地址无效. 10 环境错误. 11 试图加载格式错误的程序. 12 访问码无效. 13 数据无效. 14 存储器不足, 无法完成此操作. 15 系
  • 在storm集群环境下发布Topology roadrunners 集群stormtopologyspoutbolt
    storm的topology设计和开发就略过了。本章主要来说说如何在storm的集群环境中，通过storm的管理命令来发布和管理集群中的topology。   1、打包 打包插件是使用maven提供的maven-shade-plugin，详细见maven-shade-plugin。 <plugin> <groupId>org.apache.maven.
  • 为什么不允许代码里出现“魔数” tomcat_oracle java
    　　在一个新项目中，我最先做的事情之一，就是建立使用诸如Checkstyle和Findbugs之类工具的准则。目的是制定一些代码规范，以及避免通过静态代码分析就能够检测到的bug。 　　迟早会有人给出案例说这样太离谱了。其中的一个案例是Checkstyle的魔数检查。它会对任何没有定义常量就使用的数字字面量给出警告，除了-1、0、1和2。 　　很多开发者在这个检查方面都有问题，这可以从结果
  • zoj 3511 Cake Robbery(线段树) 阿尔萨斯 线段树
    题目链接：zoj 3511 Cake Robbery 题目大意：就是有一个N边形的蛋糕，切M刀，从中挑选一块边数最多的，保证没有两条边重叠。 解题思路：有多少个顶点即为有多少条边，所以直接按照切刀切掉点的个数排序，然后用线段树维护剩下的还有哪些点。 #include <cstdio> #include <cstring> #include <vector&
按字母分类： ABCDEFGHIJKLMNOPQRSTUVWXYZ其他