HibernateSummary

Hibernate bietet Caching- und Snapshot-Mechanismen, um die Leistung zu verbessern.

Sein Cache ist in Cache der ersten Ebene und Cache der zweiten Ebene unterteilt.

Hibernate-Cache der ersten Ebene: Wenn eine SQL-Anweisung in einer Transaktion ausgeführt wird, werden die zurückgegebenen Ergebnisse in der Map-Sammlung in der Sitzung gespeichert (natürlich gibt es auch Snapshots).

Test: (alle folgenden Codes befinden sich in Try/Catch-Blöcken)

Configuration config=new Configuration().configure();//configure()方法是加载src/hibernate.cfg.xml配置文件
        SessionFactory sf=config.buildSessionFactory();
        Session s=sf.openSession();//Session是高一级的对Connection的封装
        Transaction tran=null;
        try {
            tran=s.beginTransaction();
            
            //代码在此

            tran.commit();
        } catch (HibernateException e) {
            if(tran!=null){
                tran.rollback();
            }
            e.printStackTrace();
        } finally{
            s.close();
            sf.close();
        }

Abfrage: einschließlich get(), load(), nativem SQL, HQL, Criteria (orientierter als HQL (Eine Abfragemethode für Objekte)

//1.get()，load()方法测试
            User u=(User) s.get(User.class, 1);//第一次查询生成SQL语句，并将结果放入缓存
            User u1=(User) s.get(User.class, 1);//第二次查询并无生成SQL语句，但结果取自缓存
            p(u==u1);//true

            //2.HQL查询
            Query q=s.createQuery("from domain.User where id=1");
            User u2=(User) q.uniqueResult();//第三次查询生成了SQL语句，但结果取自缓存
            p(u2==u);//true

            //3.原生Sql
            SQLQuery q1=s.createSQLQuery("select * from User where id=1");
            q1.addEntity(User.class);
            User u3=(User) q1.uniqueResult();//第四次查询生成了SQL语句，但结果取自缓存
            p(u3==u);//true

            //4.Criteria查询
            Criteria c=s.createCriteria(User.class);
            c.add(Restrictions.eq("id", 1));
            User u4=(User) q1.uniqueResult();//第五次查询生成了SQL语句，但结果取自缓存
            p(u4==u);//true

Zusammenfassende Abfrage:

Hinzugefügt: save(), persist()

    　　　　　　  User user = new User();//对象的瞬态
                user.setName("xiaobai");
                user.setAge(121);
                s.save(user);//对象的持久态
　　　　　　　　　 s.persist(user);

Der Unterschied zwischen den beiden Methoden besteht darin, dass der Primärschlüssel vor der Ausführung der Methode festgelegt wird und der Primärschlüssel nach der Ausführung der Methode zurückgegeben wird.

1, persist(), behält eine transiente Instanz bei, „garantiert“ aber nicht, dass der Bezeichner (das Attribut, das dem Bezeichner-Primärschlüssel entspricht) sofort in die persistente Instanz eingefügt wird. Die Eingabe kann verzögert werden bis zur Spülzeit.

2. save() generiert rechtzeitig einen vorübergehenden Instanzidentifikator. Er gibt den Identifikator zurück, sodass die SQL-Einfügung sofort ausgeführt wird.

User u = new User();
                u.setName("xiaobai");
                u.setAge(121);
                s.save(u);//插入数据库，并将对象瞬态转为持久态，将返回对象存入缓存
                User u1=(User) s.get(User.class, u.getId());//这次查询没有生成SQL语句，结果取自Session的缓存
                p(u1==u);//true

Löschen: delete()

User u=(User) s.get(User.class, 10);//Abfrageoperation ausführen
s.delete(u );//Konvertieren Sie den persistenten Zustand des Objekts in einen freien Zustand

Wenn Sie der Meinung sind, dass Sie zum Löschen eines Datenelements Abfragevorgänge ausführen müssen, um die Leistung zu verringern, können Sie dies natürlich tun Tun Sie dies:

Benutzer u=new User();
u.setId(5);
s.delete(u);

Update: update( )

User u=(User) s.get(User.class, 1);
u.setName("set");

Aber manchmal tun wir es nicht Die Methode s.update(object) muss nicht ausgeführt werden. Dies beinhaltet eine Funktion des Persistenzstatus des Objekts (wird auch von [Snapshot] verwendet):

Wenn sich das Objekt im persistenten Status befindet, wenn es Wenn die Daten aktualisiert werden, vergleicht das Framework sie mit dem vorherigen Snapshot. Bei Abweichungen erfolgt keine Aktion.

//当然，也可以这么做
User u=new User();//对象的瞬态，不具备自动更新功能，需要我们手动update()
u.setAge(1);
u.setId(1);
u.setName("1");
s.update(u);

Zusammenfassung:

Ein Punkt ist sehr wichtig: Obwohl die SQL-Anweisung in der Transaktion gebildet wird, wird die Datenbank erst nach der Transaktion.commit() tatsächlich betrieben.

Hibernate muss [Cache, Snapshot, Objekt-Drei-Status] und andere Dinge über Datenbankoperationen herausfinden.

Drei Zustände des Objekts:

* Vorübergehender Zustand: Steht nicht im Zusammenhang mit dem Ruhezustand, es gibt keine entsprechende ID in der Datenbanktabelle.
* Dauerhafter Zustand: Steht im Zusammenhang mit dem Ruhezustand ist eine in der Datenbanktabelle Entsprechende ID---OID
* Freier Zustand: nicht im Zusammenhang mit dem Ruhezustand, es gibt eine entsprechende ID

in der Datenbanktabelle