hibernate 基础

Hibernate:是开源的ORM框架技术，对jdbc进行了非常轻量级的对象封装,处于业务逻辑层和数据库层之间，称作持久化层。

持久化层的作用：把程序生成的对象持久化到数据库，也就是保存到数据库。

 hibernate执行流程

1.通过Configuration().configure();读取并解析hibernate.cfg.xml配置文件（下述代码简略解释）

*****

public Configuration configure() throws HibernateException {
       configure( "/hibernate.cfg.xml" );
         return this;
  }

*****

    public Configuration configure(String resource) throws HibernateException {
        LOG.configuringFromResource( resource );
        InputStream stream = getConfigurationInputStream( resource );
        return doConfigure( stream, resource );
    }

*****

protected Configuration doConfigure(InputStream stream, String resourceName) throws HibernateException {
        try {
            ErrorLogger errorLogger = new ErrorLogger( resourceName );
            Document document = xmlHelper.createSAXReader( errorLogger,  entityResolver )
                    .read( new InputSource( stream ) );
            if ( errorLogger.hasErrors() ) {
                throw new MappingException( "invalid configuration", errorLogger.getErrors().get( 0 ) );
            }
            doConfigure( document );
        }
        catch (DocumentException e) {
            throw new HibernateException( "Could not parse configuration: " + resourceName, e );
        }
        finally {
            try {
                stream.close();
            }
            catch (IOException ioe) {
                LOG.unableToCloseInputStreamForResource( resourceName, ioe );
            }
        }
        return this;
    }

*****

protected Configuration doConfigure(Document doc) throws HibernateException {
        Element sfNode = doc.getRootElement().element( "session-factory" );
        String name = sfNode.attributeValue( "name" );
        if ( name != null ) {
            properties.setProperty( Environment.SESSION_FACTORY_NAME, name );
        }
        addProperties( sfNode );
        parseSessionFactory( sfNode, name );

        Element secNode = doc.getRootElement().element( "security" );
        if ( secNode != null ) {
            parseSecurity( secNode );
        }

        LOG.configuredSessionFactory( name );
        LOG.debugf( "Properties: %s", properties );

        return this;
    }

*****

private void addProperties(Element parent) {
        Iterator itr = parent.elementIterator( "property" );
        while ( itr.hasNext() ) {
            Element node = (Element) itr.next();
            String name = node.attributeValue( "name" );
            String value = node.getText().trim();
            LOG.debugf( "%s=%s", name, value );
            properties.setProperty( name, value );
            if ( !name.startsWith( "hibernate" ) ) {
                properties.setProperty( "hibernate." + name, value );
            }
        }
        Environment.verifyProperties( properties );
    }

*****

    private void parseSessionFactory(Element sfNode, String name) {
        Iterator elements = sfNode.elementIterator();
        while ( elements.hasNext() ) {
            Element subelement = (Element) elements.next();
            String subelementName = subelement.getName();
            if ( "mapping".equals( subelementName ) ) {
                parseMappingElement( subelement, name );
            }
            else if ( "class-cache".equals( subelementName ) ) {
                String className = subelement.attributeValue( "class" );
                Attribute regionNode = subelement.attribute( "region" );
                final String region = ( regionNode == null ) ? className : regionNode.getValue();
                boolean includeLazy = !"non-lazy".equals( subelement.attributeValue( "include" ) );
                setCacheConcurrencyStrategy( className, subelement.attributeValue( "usage" ), region, includeLazy );
            }
            else if ( "collection-cache".equals( subelementName ) ) {
                String role = subelement.attributeValue( "collection" );
                Attribute regionNode = subelement.attribute( "region" );
                final String region = ( regionNode == null ) ? role : regionNode.getValue();
                setCollectionCacheConcurrencyStrategy( role, subelement.attributeValue( "usage" ), region );
            }
        }
    }

总结来说就是在Configuration类中有一个properties变量，通过类加载器动态的加载xml中配置的变量（session-factory,property,mapping），并且以key，value键值对的方式保存在properties中。

2.由hibernate.cfg.xml中的<mapping resource="com/xx/User.hbm.xml"/>读取并解析映射信息或者<mapping class="xxx">读取解析entity注释信息

3.通过config.buildSessionFactory();//创建SessionFactory

    public SessionFactory buildSessionFactory(ServiceRegistry serviceRegistry) throws HibernateException {
        LOG.debugf( "Preparing to build session factory with filters : %s", filterDefinitions );

        buildTypeRegistrations( serviceRegistry );
        secondPassCompile();
        if ( !metadataSourceQueue.isEmpty() ) {
            LOG.incompleteMappingMetadataCacheProcessing();
        }

        validate();

        Environment.verifyProperties( properties );
        Properties copy = new Properties();
        copy.putAll( properties );
        ConfigurationHelper.resolvePlaceHolders( copy );
        Settings settings = buildSettings( copy, serviceRegistry );

        return new SessionFactoryImpl(
                this,
                mapping,
                serviceRegistry,
                settings,
                sessionFactoryObserver
            );
    }

简单来说就是SessionFacrory是一个重量级的容器，里面包含了配置文件的所有信息，ServiceRegistry等等。

4.sessionFactory.openSession();//打开Sesssion

* JDBC {@link Connection connection(s} will be obtained from the
     * configured {@link org.hibernate.service.jdbc.connections.spi.ConnectionProvider} as needed
     * to perform requested work.

通过org.hibernate.service.jdbc.connections.spi.ConnectionProvider配置返回一个JDBC Connection

5.session.beginTransaction();//创建事务Transation

6.persistent operate持久化操作 //一般指Save这个方法

7.session.getTransaction().commit();//提交事务

8.关闭Session

9.关闭SesstionFactory

操作示例：

public class test_add {
    SessionFactory sessionFactory;

    @Before
    public void sessionFacroty() {
        Configuration cfg = new Configuration();

        cfg.configure();

        ServiceRegistry sr = new ServiceRegistryBuilder().applySettings(cfg.getProperties()).build();

        try {
            sessionFactory = cfg.buildSessionFactory(sr);
        } catch (Exception e) {
            // TODO: handle exception
            e.printStackTrace();
        }
    }

    @Test
    public void add() {
        Session session = sessionFactory.openSession();
        session.beginTransaction();
        Students stu = new Students();
        session.save(stu);
        session.getTransaction().commit();
        session.close();
    }
}

Configuration:用来创建SessionFactory实例

常见方法：Configuration configure()   :Use the mappings and properties specified in an application resource named hibernate.hbm.xml

SessoinFactory:一个application对应一个SessionFactory实例，它被创建以后其内部的hibernate配置和映射关系是固定不变的，对于请求，它会创建Session实例

常用方法：Session  openSession（）

Sessoin  getCurrentSession()

Session:对于SessionFactory建立的每个轻量级的Session，相当于对数据库的一次Connecion，每当需要与数据库进行交互的时候就实例化一个Session，Session中封装了持久化实例。

常见方法：void save（）

void update（）

void delete（）

SQLQuery createSQLQuery(String queryString)   Create a SQLQuery instance for the given SQL query string.

Object get(Class clazz, Serializable id)     Return the persistent instance of the given entity class with the given identifier

Transaction：对数据库操作的封装对象，在session执行CRUB操作后，必须手动提交事务，对象才会写入数据库，也可以设置自动提交：

注：使用Session的doWork方法，重写execute方法，虽然不用提交事务，但Sesion.save()后需要Session.flush();

常用方法:void begin()

void commit()

hibernate.cfg.xm常见配置

详情见：http://www.cnblogs.com/kundeg/p/7153452.html

hibernate.show_sql--打印出sql语句

hibernate.format_sql--格式化sql语句

hibernate.dialect-数据库方言，针对不同数据库不同

hbm2ddl.auto : create表示每次生成新的表结构，删除已存在的表再创建新表

update，表示在原有表结构的基础上进行更新，保留原有的数据，对表结构进行更新，并插入新的数据

connection.url  connection.username  connection.password connection.driver_name

持久化类设计原则：

1.公有的类，私有属性

2.提供公有的不带参数的默认的构造方法

3.属性setter、getter封装

4.最好有像id一样作为标识符的属性

 Junit测试

@Before：初始化方法（表示在测试前会先执行before方法进行初始化）

@Test：要测试的方法

@After：释放资源。

openSession与getCurrentSession的区别

1.getCurrentSession在事务提交或者回滚之后会自动关闭，而openSession需要手动关闭，否者会造成连接池溢出，

2.openSession每次创建新的Session对象（对应不同的Connection），getCurrentSession使用现有的Session对象（对应相同的Connection）。

3.使用getCurrentSession获得Session还需要在cfg中配置：

如果是本地事物(jdbc)：<property name="hibernate.current_session_context_class">thread</property>

如果是全局事务(jta)：<property name="hibernate,current_session_context_class">jta</property>

Session与Connection的关系

一个Session对应一个Connection而一个Connection可以在不同时刻对应多个Session。

Session中get方法和load方法的区别

1.在不考虑缓存的情况下，get方法会在调用之后立即向数据库发出sql语句，返回持久化对象。 load方法会在调用之后返回一个代理对象。 该代理对象只保存了实体对象的id，直到使用对象的非主键属性时才会发出sql语句。

2.在大部分情况下load的延迟加载机制比get好，但是load会产生LazyInitializationException，当在session关闭后才调用load加载对象的其他属性的时候就会报出这个异常。

3.查询数据库中不存在的数据时，get方法会暴NullPointException,而load方法会抛出ObjectNotFound异常

更加具体的实例http://www.cnblogs.com/xiaoluo501395377/p/3371776.html

CLOB和BLOB的区别

1.CLOB使用CHAR来保存数据。 如：保存XML文档。

2. BLOB就是使用二进制保存数据。 如：保存位图，声音

3.都可以保存大对象

assigned与native区别

assigned：由java应用程序负责生成（手工赋值），没有赋值的话，int型默认为0；其他类型会报错

native：由底层数据库自动生成标识符，如果是MySQL就是increment，如果是Oracle就是sequence

hql与sql区别

1.hql操作的目标是持久化对象，sql操作的目标是数据库,在语法结构上大致相同。

2.由于第一条区别的存在，hql语句对大小写敏感，而sql语句则不敏感