JavaScript里面只有object和function具有对象化的能力。


函数的对象化的能力
任何一个函数都可以动态的添加或去除属性，这些属性可以是简单类型，可以是对象，也可以是其它对象函数（说来说去，就是要表达函数就是对象的一种，可以把它当作对象）。
function a(){alert(a.pa+"  "+a.pb);}
a.pa="aaa";//添加属性a
a.pb="bbb";//添加属性b
a();




var anObject={};//一个对象
anObject.aProperty="This
 is a property!";//对象的一个属性
anObject.aMethod=function(){
    alert("This
 is a method of property!");
};//对象的一个方法
alert(anObject.aProperty+"   "+anObject["aProperty"]);
anObject.aMethod();
anObject["aMethod"]();
for(var a in anObject){
    alert(a+"
 is a "+typeof(anObject[a]));
}​

var anObject=function(){};//一个函数
anObject.aProperty="This
 is a property!";//函数的一个属性
anObject.aMethod=function(){
    alert("This
 is a method of property!");
};//函数的一个方法
alert(anObject.aProperty+"   "+anObject["aProperty"]);
anObject.aMethod();
anObject["aMethod"]();
for(var a in anObject){
    alert(a+"
 is a "+typeof(anObject[a]));
}​

这里看看一个是对象，一个是函数，其它都一样！
然后看属性的两种调用方法：
    ①通过“.属性名”来调用
    ②通过数组的下标形式“["属性名"]”
不过如果调用的属性是函数，则需要加上“()”来调用。

持久化对象能更新数据库是因为它依赖了hibernate的一级缓存区域的，在Hibernate中有三级缓存，其中Hibernate中的一级缓存，也就是Session级别的缓存。hibernate向一级缓存放入数据时，同时保存快照数据，当修改一级缓存的时候，在flush操作时，对比缓存和快照，如果不一致，自动更新。

当commit时，会判断缓存中的数据与快照区域的数据是否一样，如果不一样，会发生update语句进行修改

我们已经知道，通过new新创建一个持久化实例时，该实例处于瞬态，为了让瞬态对象转换为持久化状态，Hibernate Session提供了两个方法：

Serializable save(Object obj)    将obj对象转变为持久化状态，该对象的属性将被保存到数据库

void persist(Object obj)    将obj对象转变为持久化状态，该对象的属性将被保存到数据库

因此为了将一个处于瞬态的对象变成持久化状态，可以看如下代码片段：

News n=new News();

n.setTitle("知无涯者:拉马努金");

n.setContent("Xxxxxxxxxxxxxx");

session.save(n);

当我们将一个瞬态实例变成持久化状态时，Hibernate会在底层对应地生成一条insert语句，这条语句负责把该实例对应的数据插入数据表。

① 如果News的标识属性是generated，也就是说指定了主键生成器，那么Hibernate将会在执行save方法时自动生成标识属性值，并将该标识属性值分配给该News对象。

② 如果News的标识属性是assigned类型的，或者是联合主键，那么该标识属性值应当在调用save之前手动赋给News对象。

注意：

Hibernate之所以提供与save( )功能几乎完全类似的persist( )方法，一方面是为了照顾JPA的用法习惯。另一方面save和persist还有一个区别：使用save( )方法保存持久化对象时，该方法返回该持久化对象的标识属性值即对应记录的主键值；但persist( )方法保存持久化对象时，没有任何返回值。因为save方法需要立即返回持久化对象的标识属性值，所以程序执行save( )方法时会立即将持久化对象对应的数据插入数据库。而persist方法则保证当它在一个事物外部被调用时，并不立即转换成insert语句，这个功能是很有用的，尤其当我们封装一个长会话流程的时候，persist就显得尤为重要了。

load( )与get( )：

也可以通过load( )来加载一个持久化实例，这种加载就是根据持久化类的标识属性值加载持久化实例------其实质就是根据主键从数据表中加载一条新记录。News n=session.load(News.class,new Integer(pk))；pk就是需要加载的持久化实例的标识属性。

如果没有匹配的数据库记录，load( )方法可能抛出HibernateException异常；如果我们在类映射文件中指定了延迟加载，则load( )方法会返回一个未初始化的代理对象，这个代理对象并没有装载数据记录，知道程序调用该代理对象的某方法时，Hibernate才会去访问数据库。

如果希望在某对象中创建一个指向另一个对象的关联，又不想在从数据库中装载该对象的同时装载相关联的所有对象，这种延迟加载的方式就非常有用了。

与load( )方法类似的是get( )方法，get( )方法也用于根据主键装载持久化实例，但get( )方法会立刻访问数据库，如果没有对应的记录，get( )方法返回null，而不是返回一个代理对象。

一旦加载了该持久化实例后，该实体就处于持久化状态，在代码中对持久化实例所做的修改，例如：n.setTitle("新标题");这种修改将被保存到数据库，对标题的修改被映射成修改数据表的特定行的特定列。

程序对持久化实例所做的修改会在Session flush之后被自动保存到数据库，无需程序调用其他方法(不需要调用update方法)来将修改持久化。也就是说，修改对象最简单的方法就是在Session处于打开状态时load，或get它，然后直接修改即可。

对于一个曾经持久化过的、但现在已脱离Session管理的持久化对象，我们把它称为处于脱管状态。当我们修改脱管对象的状态后，程序应该使用新的Session来保存这些修改。Hibernate提供了update( )、merge( )和updateOrSave( )等方法来保存这些修改。

News n=firstSession.load(News.class,new Integer(pk));

firstSession.close();

n.setTitle("新标题");

Session secondSession=HibernateSessionFactory.getSession();

secondSession.update(n);

当我们用另一个Session来保存这种修改后，该脱管对象再次回到Session的管理之下，也就再次回到持久化状态。

当需要使用update( )来保存程序对持久化对象所做的修改时，如果不清楚该对象是否曾经持久化过，那么程序可以选择使用updateOrSave( )方法，该方法自动判断该对象是否曾经持久化，如果曾经持久化过，就使用update方法，否则将使用save操作。

merge( )方法也可将程序对脱管对象所做的修改保存到数据库，但merge方法与update方法最大的区别就是：merge( )方法不会持久化给定对象。举例来说，当我们执行session.update(a)代码后，a对象将会变成持久化状态；而执行session.merge(a)代码后，a对象依然不是持久化状态，a对象依然不会被关联到Session上。

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

在hibernate中，持久化对象分为三种状态：

1）瞬时态 transient  (临时对象) ：无持久化标识OID，未与Session关联 ,

2）持久态 persistent  :存在持久化标识OID，与Session关联

3）脱管态 detached （离线对象）:存在持久化标识OID，未与Session关联 (session.close)

对象的状态可以相互之间进行转换

直接获得瞬时态对象：new Customer()

瞬时 --》持久 session.save(customer);

瞬时 --》托管 customer.setId(1);

直接获得持久态对象：session.get();

持久 --》瞬时 session.delete();

持久 --》托管 sesion.evict,session.close,session.clear,清除对象在一级缓存中的引用

直接获得托管对象：不能直接获得

托管 --》瞬时 删除OID

托管 --》持久 update ，saveOrUpdate

而只要session存在，它的缓存的生命周期就一直存在。Session flush的三种情况为事务提交、调用查询方法(query)以及手动调用flush，session.close()。

持久化对象在一级缓存中的值改变后，与所对应的快照区的数据不同，每当触发Session flush后，会主动更新数据库，例如：

    @Test

    public void test123() {

        Session session =sessionFactory.getCurrentSession();

        Transaction tx = session.beginTransaction();

        //c持久态------存在于session的缓存中

        Customer c1 = (Customer) session.get(Customer.class, 1);

        

        //改变持久态对象

        c1.setName("rose");

        

        Query query = session.createQuery("from Customer");

        //list查询时会flush

        query.list();

        

        //事务提交时会flush

        tx.commit();

        session.close();

 

        // 因为session已经关闭，托管态对象

        System.out.println(c1.getId());

    }

在上述方法中，当程序执行到query.list()时，会自动更对象c1,，而在事务提交以及session关闭时，持久化对象c1的值与快照区的值相同，故不会执行update。此方法中的update执行在两个select之间。

再写一些它们的区别：

session.save():实体被纳入session缓存，session计划执行sql，此时查询不会有结果（无插入sql的执行）;

session.flush():session“清理”缓存，发送执行sql，但不提交事务，此时在同一session中执行查询可以查询到结果（处于同一个数据库会话，尽管该会话的事物尚未提交，数据库中无真实的数据，此时查询到的应该是数据库本身事务机制的缓存），但在另外的查询中不会有结果（比如在native mysql中，因为不处于同一个数据库会话中）；

commit():发送执行sql并提交事务；事务完成

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

作者：记录点滴人生 

来源：CSDN 

原文：https://blog.csdn.net/wodatoucai/article/details/17427005 

版权声明：本文为博主原创文章，转载请附上博文链接！

作者：confirmAname 

来源：CSDN 

原文：https://blog.csdn.net/confirmaname/article/details/9290535 

版权声明：本文为博主原创文章，转载请附上博文链接！

 

1.对象序列化定义

对象序列化指的是将内存中保存的对象以二进制数据流的形式进行处理，可以是实现对象的保存或者网络传输。并不是所有的对象都可以被序列化，在Java中有有一个强制性的要求：一个对象如果要进行序列化，那么这个对象所在的类一定要实现java.io.Serializable父接口，作为序列化的标记，它描述的是一种类的能力。

2.序列化的实现

有了序列化的支持类后，如果想要实现序列化和反序列化就可以利用以下两个类：

序列化：ObjectOutputStream
类定义：public class ObjectOutputStream extends OutputStream implements ObjectOutput, ObjectStreamConstants

构造方法：public ObjectOutputStream(OutputStream out) throws IOException
操作方法：public final void writeObject(Object obj) throws IOException

反序列化：ObjectInputStream
类定义：public class ObjectInputStream extends InputStream implements ObjectInput,ObjectStreamConstants

构造方法：public ObjectInputStream(InputStream in) throws IOException
操作方法：public final Object readObject() throws IOException, ClassNotFoundException


在Java中的对象序列化与反序列化必须使用内部提供的对象操作流，因为这里面牵扯到了二进制数据的格式，所以不能自定义处理，另外如果想要实现一组对象的序列化，则可以使用对象数组完成。

3.transient关键字

默认情况下当执行了对象的序列化时，会将类中的全部属性的内容进行全部的序列化，但是很多情况下，有一些属性可能并不需要进行序列化的处理，这个时候就可以在属性定义上使用transient关键字来完成了。

例如：
private transient Integer age;

对象序列化基本概念

几乎只要是java开发就一定存在序列化的概念，而正是因为序列化的概念逐步发展，慢慢也就有了更多的序列化标注。

序列化的基本定义：将内存中保存的对象以二进制数据流的形式进行处理，可以实现对象的保存或者是网路传输。



 然而并不是所有的对象都可以被序列化，在Java中有一个强制性的要求：如果要序列化对象，那么对象所在的类一定要实现java.io.Serializable父接口，作为序列化的标记。这个接口没有任何方法，它描述的是一只类的能力。

范例：定义一个可以被序列化的类

class Person implements Serializable{   //Person类可以被序列化

    private String name;
    private int age;

    public Person(String name,int age){
        this.name  = name ;
        this.age = age;
    }
    @Override
    public String toString(){
        return "姓名："+this.name+"、年龄："+this.age;
    }
}

此时Person产生的每一个对象都可以实现二进制的数据传输，属于可以被序列化的程序类。