Hibernate

1.Hibernate初步了解

(1)什么是hibernate,hibernate是用来做什么的

半成品的项目

hibernate是一个操作数据库的框架，实现了对JDBC的封装。

2.使用c3p0与dbutils编写用户注册功能

所需jar包如下

所建包结构如下：

主要代码如下

userdao层:

package com.dao;

import java.sql.SQLException;

import org.apache.commons.dbutils.QueryRunner;

import com.domain.User;
import com.yl.lain.utils.C3p0DataSourceUtils;

public class UserDao {

    public void addUser(User user) throws SQLException {
        QueryRunner runner=new QueryRunner(C3p0DataSourceUtils.getDataSource());
        String sql="insert into user2 values(?,?,?,?,?,?)";
        runner.update(sql,user.getId(),user.getUsername(),user.getPassword(),user.getName(),user.getEmail(),user.getTelephone());
    }

}

View Code

c3p0xml配置文件如下：

<?xml version="1.0" encoding="UTF-8"?>
<c3p0-config>

    <default-config>
        <property name="driverClass">com.mysql.jdbc.Driver</property>
        <property name="jdbcUrl">jdbc:mysql://localhost:3306/world?useSSL=false</property>
        <property name="user">root</property>
        <property name="password">root</property>
        <property name="initialPoolSize">5</property>
        <property name="maxPoolSize">20</property>
    </default-config>


    <named-config name="oracel">
        <property name="driverClass">oracle.jdbc.driver.OracleDriver</property>
        <property name="jdbcUrl">jdbc:oracle:thin:@//192.168.40.128/orcl</property>
        <property name="user">scott</property>
        <property name="password">scott</property>
    </named-config>


</c3p0-config>

View Code

domain：

package com.domain;

public class User {
    private String id;
    private String username;
    private String password;
    private String name;
    private String email;
    private String telephone;
    public String getId() {
        return id;
    }
    public void setId(String id) {
        this.id = id;
    }
    public String getUsername() {
        return username;
    }
    public void setUsername(String username) {
        this.username = username;
    }
    public String getPassword() {
        return password;
    }
    public void setPassword(String password) {
        this.password = password;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public String getEmail() {
        return email;
    }
    public void setEmail(String email) {
        this.email = email;
    }
    public String getTelephone() {
        return telephone;
    }
    public void setTelephone(String telephone) {
        this.telephone = telephone;
    }
    
}

View Code

service:

package com.service;

import java.sql.SQLException;

import com.dao.UserDao;
import com.domain.User;

public class UserService {

    public void addUser(User user) throws SQLException {
        UserDao userDao=new UserDao();
        userDao.addUser(user);
        
    }

}

View Code

web:

package com.web;

import java.util.UUID;

import com.domain.User;
import com.opensymphony.xwork2.ActionSupport;
import com.opensymphony.xwork2.ModelDriven;
import com.service.UserService;

public class UserAction extends ActionSupport implements ModelDriven<User>{
    public User user=new User();
    public String register() throws Exception {
        
        //封装user
        //没有的我们手动封装
        user.setId(UUID.randomUUID().toString());
        //传递数据
        UserService userService=new UserService();
        userService.addUser(user);
        return "tologin";
    }
    @Override
    public User getModel() {
        
        return user;
    }

}

View Code

struts:

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE struts PUBLIC
    "-//Apache Software Foundation//DTD Struts Configuration 2.5//EN"
    "http://struts.apache.org/dtds/struts-2.5.dtd">
<struts>
    <constant name="struts.devMode" value="true"></constant>
    <constant name="struts.enable.DynamicMethodInvocation" value="true"></constant>
    <package name="forum" namespace="/" extends="struts-default">
       <global-allowed-methods>regex:.*</global-allowed-methods>
        <action name="UserAction_*" class="com.web.UserAction" method="register">
        <result name="tologin" type="redirect">/login.html</result>
        </action>
    </package>
</struts>

View Code

3.使用hibernate编写用户注册功能

搭建hibernate

struts.xml

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE struts PUBLIC
    "-//Apache Software Foundation//DTD Struts Configuration 2.5//EN"
    "http://struts.apache.org/dtds/struts-2.5.dtd">
<struts>
    <constant name="struts.devMode" value="true" />
    <constant name="struts.enable.DynamicMethodInvocation" value="true" />
    
    <package name="hibernate" namespace="/" extends="struts-default">
        <global-allowed-methods>regex:.*</global-allowed-methods>
        <action name="UserAction_*" class="com.web.UserAction" method="{1}">
            <result name="tologin" type="redirect">/login.html</result>
        </action>
        
    </package>

</struts>

View Code

hibernate.cfg.xml

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE struts PUBLIC
    "-//Apache Software Foundation//DTD Struts Configuration 2.5//EN"
    "http://struts.apache.org/dtds/struts-2.5.dtd">
<struts>
    <constant name="struts.devMode" value="true" />
    <constant name="struts.enable.DynamicMethodInvocation" value="true" />
    
    <package name="hibernate" namespace="/" extends="struts-default">
        <global-allowed-methods>regex:.*</global-allowed-methods>
        <action name="UserAction_*" class="com.web.UserAction" method="{1}">
            <result name="tologin" type="redirect">/login.html</result>
        </action>
        
    </package>

</struts>

View Code

dao层:

package com.dao;

import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.hibernate.Transaction;
import org.hibernate.cfg.Configuration;

import com.domain.User;

public class UserDao {

    public void addUser(User user) {
        
        //使用hibernate
        //得到配置信息
        Configuration config=new Configuration().configure();
        //创建sessionfactory对象
        SessionFactory sessionFactory = config.buildSessionFactory();
        //获取session
        Session session = sessionFactory.openSession();
    
        //打开事务
        Transaction transaction = session.beginTransaction();
        //存储user对象
        session.save(user);
        //提交事务
        transaction.commit();
        //关闭资源
        session.close();
        
    }

}

View Code

domain层:

user

package com.domain;


public class User {

    
    private String id;
    private String username;
    private String password;
    private String name;
    private String email;
    private String telephone;
    
    
    
    public String getId() {
        return id;
    }
    public void setId(String id) {
        this.id = id;
    }
    public String getUsername() {
        return username;
    }
    public void setUsername(String username) {
        this.username = username;
    }
    public String getPassword() {
        return password;
    }
    public void setPassword(String password) {
        this.password = password;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public String getEmail() {
        return email;
    }
    public void setEmail(String email) {
        this.email = email;
    }
    public String getTelephone() {
        return telephone;
    }
    public void setTelephone(String telephone) {
        this.telephone = telephone;
    }
    @Override
    public String toString() {
        return "User [id=" + id + ", username=" + username + ", password=" + password + ", name=" + name + ", email="
                + email + ", telephone=" + telephone + "]";
    }
    
    
    
    
}

View Code

user.hbm.xml

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE hibernate-mapping PUBLIC 
    "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
    "http://www.hibernate.org/dtd/hibernate-mapping-3.0.dtd">

<hibernate-mapping>
<class name="com.domain.User" table="user2">
        <id name="id" column="id">
        <!-- 主键生成策略 (手动生成)-->
            <generator class="assigned"></generator>
        </id>
        <property name="username" column="username"></property>
        <property name="password" column="password"></property>
        <property name="name" column="name"></property>
        <property name="email" column="email"></property>
        <property name="telephone" column="telephone"></property>
    </class>
</hibernate-mapping>

View Code

service层:

package com.service;

import com.dao.UserDao;
import com.domain.User;

public class UserService {

    public void addUser(User user) {
        UserDao dao=new UserDao();
        dao.addUser(user);
    }

}

View Code

web层:

userAction.java

package com.web;

import java.util.UUID;

import com.domain.User;
import com.opensymphony.xwork2.ActionSupport;
import com.opensymphony.xwork2.ModelDriven;
import com.service.UserService;

public class UserAction extends ActionSupport implements ModelDriven<User>{

    
    User user=new User();
    public String register() throws Exception {
        user.setId(UUID.randomUUID().toString());
        UserService userService=new UserService();
        userService.addUser(user);
        
        return "tologin";
    }

    @Override
    public User getModel() {
        // TODO Auto-generated method stub
        return user;
    }
    
}

View Code

4.对比这两种方式

创建:

　　hibernate:

创建hibernate。cfg.xml

　　　　　　配置驱动，数据url,用户名,密码

　　　　　　数据库的方言

　c3p0+dbutils:

　　　　　　c3p0:连接数据库

　　　　　　　　配置驱动，数据库url,用户名,密码

　　　　　　dbutils:操作数据库

添加实体:

　　　　hibernate:

　　　　　　　需要实体与表的映射文件xxx.hbm.xml

　　　　　　　需要配置属性与字段的对应,添加逐渐生成策略

　　　　c3p0+dbutils:

　　　　　　需要实体

操作数据库:

　　　　hibernate:

　　　　　　　　通过session来操作数据库(开启事务)

　　　　　　　　如何操作MySQL中的表:

　　　　　　　　　　不用写sql语句(hibernate帮你写),而且一行代码解决session.save();

　　　　原始的c3p0+dbutils:

　　　　　　　　通过queryrunner来操作数据库

　　　　　　　　如何操作MySQL中的表:

写sql语句，相对比与hibernate会比较麻烦，insert into user values(?,?,?,?......)

5.学习hibernate(重点)

(1)hibernate配置文件的讲解

配置数据库方言：

打开hibernate-core.final.jar

找到

若想hibernate自动生成表，要配置成如下的方言

create: 自动创建表，每次框架运行都会创建一张新的表，原来的数据将丢失(开发)
create-drop: 自动建表，每次框架运行结束都会删除所有的表(开发环境中测试使用)
update(推荐): 自动生成表，如果表已经存在，则更新数据，添加数据，如果表不存在，就会创建一张新的表。
validate:

配置mapping映射文件

格式化hibernate生成的sql语句

配置事务的隔离级别

配置事务

从而得到同一个session

其他配置

hibernate.cnf.xml如下:

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE hibernate-configuration PUBLIC
    "-//Hibernate/Hibernate Configuration DTD 3.0//EN"
    "http://www.hibernate.org/dtd/hibernate-configuration-3.0.dtd">
<hibernate-configuration>
    <!-- 负责初始化hibernate -->
    <session-factory>
        <!-- 连接数据库的驱动 -->
        <property name="hibernate.connection.driver_class">com.mysql.jdbc.Driver</property>
        <!-- 数据库地址 -->
        <property name="hibernate.connection.url">jdbc:mysql://localhost:3306/world?useSSL=false</property>
        <!-- 数据库用户名 -->
        <property name="hibernate.connection.username">root</property>
        <!-- 数据库密码 -->
        <property name="hibernate.connection.password">root</property>
         <!-- 配置数据库的方言 -->
        <property name="hibernate.dialect">org.hibernate.dialect.MySQL5InnoDBDialect</property>
        <!-- 将hibernate生成的sql语句打印到控制台 -->
        <property name="hibernate.show_sql">true</property>
        <!-- 格式化hibernate生成的sql语句 -->
        <property name="hibernate.format.sql">true</property>
        
        
        <!-- hibernate自动创建表
            create: 自动创建表，每次框架运行都会创建一张新的表，原来的数据将丢失(开发)
            create-drop: 自动建表，每次框架运行结束都会删除所有的表(开发环境中测试使用)
            update(推荐): 自动生成表，如果表已经存在，则更新数据，添加数据，如果表不存在，就会创建一张新的表。
            validate:
         -->
         
         <property name="hibernate.hbm2ddl.auto">create</property>
           
        
        <!-- 映射文件配置 -->
        <mapping resource="com/domain/User.hbm.xml"/>
    </session-factory>
    
</hibernate-configuration>

View Code

实体映射配置文件的讲解xxx.hbm.xml

主键生成策略5种

identity：主键自增
sequence:oracle中主键生成策略
native：identity+sequence(hibernate会根据连接的数据库自动选择(identity,sequence))
uuid:产生随机字符串作为主键，主键必须为String
assigned:我们要手动去指定

若是手动生成，还需在action中设置id为字符串格式

id元素

其他元素

user.hbm.xml

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE hibernate-mapping PUBLIC 
    "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
    "http://www.hibernate.org/dtd/hibernate-mapping-3.0.dtd">

<hibernate-mapping package="com.domain">
    <class name="User" table="user2">
        <!-- id元素 name:实体中的属性 colum(可选):数据库的列名(一样的话可以不用配置) type(可选属性):填写列(属性)的类型.hibernate会自动检测实体的属性类型。每个类型有三种 
            填法:java类型|hibernate类型|数据库类型 length(可选):配置数据库中列的长度，默认值:使用数据库类型的最大长度。 -->
        <id name="id" column="id">
            <!-- identity：主键自增 sequence:oracle中主键生成策略 
                native：identity+sequence(hibernate会根据连接的数据库自动选择(identity,sequence)) 
                uuid:产生随机字符串作为主键，主键必须为String 
                assigned:我们要手动去指定 -->
            <!-- 主键生成策略 (手动生成) -->
            <generator class="uuid"></generator>
        </id>
        <!-- property:除了id之外的普通属性 name:实体中的属性 colum(可选):数据库的列名 length(可选):配置数据库中列的长度 
            默认值：使用数据库类型的最大长度 not-null(可选):配置该属性是否不能为空，默认值false -->
        <property name="username" column="username"></property>
        <property name="password" column="password"></property>
        <property name="name" column="name"></property>
        <property name="email" column="email"></property>
        <property name="telephone" column="telephone"></property>
    </class>
</hibernate-mapping>

View Code

(2)api的讲解

dao层：

1.Configuration

创建Configuration对象，并未读取-----》通过对象调用configure()方法读取配置文件信息。

configure是怎么读取的，相关源码如下：

2.SessionFactory

功能：创建session(数据库核心对象)的工厂。简单来说就是创建session对象。

sessionfactory 负责保存和使用所有配置信息消耗内存资源很大。

线程安全的。

3.Session(重点)

package com.dao;

import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.hibernate.Transaction;
import org.hibernate.cfg.Configuration;

import com.domain.User;

public class UserDao {

    public void addUser(User user) {

        //使用hibernate(并没有读取hibernate.cfg.xml)
        Configuration config1=new Configuration();
        //读取配置文件
        config1.configure();
        //得到sessionfactory  功能：创建session(数据库核心对象)的工厂
        //                         简单来说就是创建session对象。
        //sessionfactory 负责保存和使用所有配置信息消耗内存资源很大。
        //                 线程安全的。
        SessionFactory factory = config1.buildSessionFactory();
        //创建session对象
        Session openSession=factory.openSession();

        //得到配置信息
        Configuration config=new Configuration().configure();
        //创建sessionfactory对象
        SessionFactory sessionFactory = config.buildSessionFactory();
        //获取session
        Session session = sessionFactory.openSession();

        //打开事务
        Transaction transaction = session.beginTransaction();
        //存储user对象
        session.save(user);
        //提交事务
        transaction.commit();
        //关闭资源
        session.close();

    }
    public void deleteUser(){
        Configuration config=new Configuration().configure();
        SessionFactory factory = config.buildSessionFactory();
        Session session = factory.openSession();
        Transaction beginTransaction=session.beginTransaction();
        //得到id为的对象
        User user = session.get(User.class, "402881606adf5c93016adf5caacd0001");
        session.delete(user);
        beginTransaction.commit();
        session.close();

    }
    public void ChangeUser(){
        //读取hibernate.cfg.xml
        Configuration configuration=new Configuration().configure();
           SessionFactory factory = configuration.buildSessionFactory();
           Session session = factory.openSession();
           Transaction beginTransaction = session.beginTransaction();
           //获得id为402881606adf5c93016adf5caacd0001的对象。
           User user = session.get(User.class, "402881606adf5c93016adf5caacd0001");
           //将该对象改名为trigger
           user.setUsername("trigger");
           //跟新数据库
           session.update(user);
           //提交事务
           beginTransaction.commit();
           //关闭session
           session.close();
           
    }

    public void findUser(){
        Configuration config=new Configuration().configure();
        SessionFactory factory = config.buildSessionFactory();
        Session session = factory.openSession();
        Transaction beginTransaction = session.beginTransaction();
        User user =session.get(User.class, "402881606adf5c93016adf5caacd0001");
        System.out.println(user.getName());
        beginTransaction.commit();
        session.close();
    }

}

View Code

(3)创建实体

提供无参的构造器
成员变量的私有化，提供getset方法，提供属性
尽量使用包装类
主键(实体要提供一个主键，与数据库中的列进行对应)
不要加final(hibernate 中使用代理机制)

(4)对象的三种状态

瞬时状态(transient)

实体没有id，没有和session关联(hibernate中的session)

持久化状态(persistent) 特点：持久化状态的任何改变都会同步到数据库中

实体有id，与session关联

游离态(detached 托管态)

实体，有id，没有与session关联

dao:

三种状态的转换

(5)一级缓存

dao

(6)事务管理

事务的性质

1.原子性:原子，不可再分，一个操作不能分为更小的操作，要么全都执行，要么全不执行。

2.一致性:事务在完成时，必须使得所有的数据保持一致的状态。(与开始事务前一样的状态)

3.隔离性:事务查看数据时数据所处的状态，要么是另一个并发事务修改它之前的状态，

要么是另一个并发事务修改后的状态，事务不会查看中间装态的数据。

4.持久性:事务操作之后，他对于系统的影响是永久性的。(执行了就执行了，没有撤回(反悔)的说法)

破坏了数据库。

事务的隔离级别

脏读:读取了未提交事务中的数据

不可重复读:对于数据库中的某个数据,一个事务范围内多次读取同一个数据，结果却有不同的值。

a事务第一读取值为100，b事务抢占资源，把值改为200。b事务结束。a事务接着读，值为两百。

幻读:对于多个事务操作数据库。a把数据库中的值修改了，b又改了，b事务结束了。a事务抢占了资源,发现值不对，以为产生了幻觉

不可重复读和幻读的区别：

http://www.cnblogs.com/itcomputer/articles/5133254.html

配置事务的隔离级别

1读未提交:最低的隔离级别，最没用(最快) 1(0001)

2读已提交:可避免脏读，不能避免不可重复读 2(0010)

3可重复读:可以避免可重复读，可以避免脏读(mysql默认) 4(0100)

4串行化:最强大，三种都可以解决。(最慢) 8(1000)

在hibernate.cfg.xml中：

使用事务小案例

点击按钮，根据id查找user--->找到user的名字改变

----->没找到,不做任何变化.

使一个服务为一个事务。

hibernate.cfg.xml如下：

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE hibernate-configuration PUBLIC
    "-//Hibernate/Hibernate Configuration DTD 3.0//EN"
    "http://www.hibernate.org/dtd/hibernate-configuration-3.0.dtd">
<hibernate-configuration>
    <!-- 负责初始化hibernate -->
    <session-factory>
        <!-- 连接数据库的驱动 -->
        <property name="hibernate.connection.driver_class">com.mysql.jdbc.Driver</property>
        <!-- 数据库地址 -->
        <property name="hibernate.connection.url">jdbc:mysql://localhost:3306/world?useSSL=false</property>
        <!-- 数据库用户名 -->
        <property name="hibernate.connection.username">root</property>
        <!-- 数据库密码 -->
        <property name="hibernate.connection.password">root</property>
         <!-- 配置数据库的方言 -->
        <property name="hibernate.dialect">org.hibernate.dialect.MySQL5InnoDBDialect</property>
        <!-- 将hibernate生成的sql语句打印到控制台 -->
        <property name="hibernate.show_sql">true</property>
        <!-- 格式化hibernate生成的sql语句 -->
        <property name="hibernate.format.sql">true</property>
        
        
        <!-- hibernate自动创建表
            create: 自动创建表，每次框架运行都会创建一张新的表，原来的数据将丢失(开发)
            create-drop: 自动建表，每次框架运行结束都会删除所有的表(开发环境中测试使用)
            update(推荐): 自动生成表，如果表已经存在，则更新数据，添加数据，如果表不存在，就会创建一张新的表。
            validate:
         -->
         
         <property name="hibernate.hbm2ddl.auto">update</property>
           <!-- 
           1(0001)读未提交:最低的隔离级别，最没用(最快)
           2(0010)读已提交:可避免脏读，不能避免不可重复读
           4(0100)可重复读:可以避免可重复读，可以避免脏读(mysql默认)
           8(1000)串行化:最强大，三种都可以解决。(最慢)
            -->
            <property name="hibernate.connection.isolation">4</property>
        <!-- 配置事务 (session与当前线程绑定)-->
        <property name="hibernate.current_session_context_class">thread</property>
        <!-- 映射文件配置 -->
        <mapping resource="com/domain/User.hbm.xml"/>
    </session-factory>
    
</hibernate-configuration>

View Code

struts.xml如下

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE struts PUBLIC
    "-//Apache Software Foundation//DTD Struts Configuration 2.5//EN"
    "http://struts.apache.org/dtds/struts-2.5.dtd">
<struts>
    <constant name="struts.devMode" value="true" />
    <constant name="struts.enable.DynamicMethodInvocation" value="true" />
    
    <package name="hibernate" namespace="/" extends="struts-default">
        <global-allowed-methods>regex:.*</global-allowed-methods>
        <action name="UserAction_*" class="com.web.UserAction" method="{1}">
            <result name="tologin" type="redirect">/login.html</result>
        </action>
        
    </package>

</struts>

View Code

web层：

package com.web;

import java.util.UUID;

import com.domain.User;
import com.opensymphony.xwork2.ActionSupport;
import com.opensymphony.xwork2.ModelDriven;
import com.service.UserService;

public class UserAction extends ActionSupport implements ModelDriven<User>{

    
    User user=new User();
    public String register() throws Exception {
        //user.setId(UUID.randomUUID().toString());
        UserService userService=new UserService();
        userService.addUser(user);
        
        return "tologin";
    }

    
    public User getModel() {
        // TODO Auto-generated method stub
        return user;
    }
    
}

View Code

service层

package com.service;

import org.hibernate.Session;
import org.hibernate.Transaction;

import com.dao.UserDao;
import com.domain.User;
import com.utils.HibernateUtils;

public class UserService {

    public void addUser(User user) {
        UserDao dao=new UserDao();
        //开启事务
        Session currentSession = HibernateUtils.getCurrentSession();
        Transaction beginTransaction = currentSession.beginTransaction();
        try{
            //根据查找tuser
            //dao.addUser();
            User tuser=dao.findUserById("1");
            if(tuser!=null){
                //如果找到了，根据id修改名字
                dao.ChangeUserByUserId(tuser.getId());
            }
            else{
                
            }
        }catch(Exception e){
            e.printStackTrace();
            //事务的回滚
            beginTransaction.rollback();
        }
        
        //提交事务
        beginTransaction.commit();
    }

}

View Code

dao层

package com.dao;

import org.hibernate.Hibernate;
import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.hibernate.Transaction;
import org.hibernate.cfg.Configuration;

import com.domain.User;
import com.utils.HibernateUtils;

public class UserDao {

    public void addUser(/*User user*/) {

        /*//使用hibernate(并没有读取hibernate.cfg.xml)
        Configuration config1=new Configuration();
        //读取配置文件
        config1.configure();
        //得到sessionfactory  功能：创建session(数据库核心对象)的工厂
        //                         简单来说就是创建session对象。
        //sessionfactory 负责保存和使用所有配置信息消耗内存资源很大。
        //                 线程安全的。
        SessionFactory factory = config1.buildSessionFactory();
        //创建session对象
        Session openSession=factory.openSession();*/

        
        
        Session session = HibernateUtils.getSession();
        Transaction transaction = session.beginTransaction();                
         User user=new User(); //=>瞬时状态
         user.setName("lain");//=>瞬时状态                
        //存储user对象              只是为了生成id
        session.save(user);  //有id，与session关联 持久化状态  本质：对象状态的转换
                                //将瞬时--->持久        目的：生成id
        //提交事务
        transaction.commit();
        //关闭资源
        session.close(); //没有与session关联，有id。

    }
    public void deleteUser(){
        Configuration config=new Configuration().configure();
        SessionFactory factory = config.buildSessionFactory();
        Session session = factory.openSession();
        Transaction beginTransaction=session.beginTransaction();
        //得到id为的对象
        User user = session.get(User.class, "402881606adf5c93016adf5caacd0001");
        session.delete(user);
        beginTransaction.commit();
        session.close();

    }
    public void ChangeUser(){
        //读取hibernate.cfg.xml
        Configuration configuration=new Configuration().configure();
           SessionFactory factory = configuration.buildSessionFactory();
           Session session = factory.openSession();
           Transaction beginTransaction = session.beginTransaction();
           //获得id为402881606adf5c93016adf5caacd0001的对象。
           User user = session.get(User.class, "402881606adf5c93016adf5caacd0001");
           User user1 = session.get(User.class, "1");
           User user2 = session.get(User.class, "1");
           System.out.println(user1==user2);
           //将该对象改名为trigger
           user.setUsername("trigger");
           //跟新数据库
           session.update(user);
           //提交事务
           beginTransaction.commit();
           //关闭session
           session.close();
           
    }

    public void findUser(){
        Configuration config=new Configuration().configure();
        SessionFactory factory = config.buildSessionFactory();
        Session session = factory.openSession();
        Transaction beginTransaction = session.beginTransaction();
        User user =session.get(User.class, "402881606adf5c93016adf5caacd0001");
        System.out.println(user.getName());
        beginTransaction.commit();
        session.close();
    }
    public User findUserById(String id) {
        Session session=HibernateUtils.getCurrentSession();
        return     session.get(User.class, id);

    }
    public void ChangeUserByUserId(String id) {
        // TODO Auto-generated method stub
        Session session=HibernateUtils.getCurrentSession();
        //先拿到持久化user
        User user=session.get(User.class,id);
        //改变user(从持久态--->beginTransaction.commit()他才会同步到数据库)
        user.setUsername("trigger");
    }

}

View Code

domain层：

package com.domain;


public class User {

    
    private String id;
    private String username;
    private String password;
    private String name;
    private String email;
    private String telephone;
    
    
    
    public String getId() {
        return id;
    }
    public void setId(String id) {
        this.id = id;
    }
    public String getUsername() {
        return username;
    }
    public void setUsername(String username) {
        this.username = username;
    }
    public String getPassword() {
        return password;
    }
    public void setPassword(String password) {
        this.password = password;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public String getEmail() {
        return email;
    }
    public void setEmail(String email) {
        this.email = email;
    }
    public String getTelephone() {
        return telephone;
    }
    public void setTelephone(String telephone) {
        this.telephone = telephone;
    }
    @Override
    public String toString() {
        return "User [id=" + id + ", username=" + username + ", password=" + password + ", name=" + name + ", email="
                + email + ", telephone=" + telephone + "]";
    }
    
    
    
    
}

View Code

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE hibernate-mapping PUBLIC 
    "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
    "http://www.hibernate.org/dtd/hibernate-mapping-3.0.dtd">

<hibernate-mapping package="com.domain">
    <class name="User" table="user2">
        <!-- id元素 name:实体中的属性 colum(可选):数据库的列名(一样的话可以不用配置) type(可选属性):填写列(属性)的类型.hibernate会自动检测实体的属性类型。每个类型有三种 
            填法:java类型|hibernate类型|数据库类型 length(可选):配置数据库中列的长度，默认值:使用数据库类型的最大长度。 -->
        <id name="id" column="id">
            <!-- identity：主键自增 sequence:oracle中主键生成策略 
                native：identity+sequence(hibernate会根据连接的数据库自动选择(identity,sequence)) 
                uuid:产生随机字符串作为主键，主键必须为String 
                assigned:我们要手动去指定 -->
            <!-- 主键生成策略 (手动生成) -->
            <generator class="uuid"></generator>
        </id>
        <!-- property:除了id之外的普通属性 name:实体中的属性 colum(可选):数据库的列名 length(可选):配置数据库中列的长度 
            默认值：使用数据库类型的最大长度 not-null(可选):配置该属性是否不能为空，默认值false -->
        <property name="username" column="username"></property>
        <property name="password" column="password"></property>
        <property name="name" column="name"></property>
        <property name="email" column="email"></property>
        <property name="telephone" column="telephone"></property>
    </class>
</hibernate-mapping>

View Code

utils层

package com.utils;

import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.hibernate.cfg.Configuration;

public class HibernateUtils {
    private static SessionFactory sessionFactory=null;
    static{
        //读取hibernate.cfg.xml
                Configuration config=new Configuration().configure();
                //获取sessionFactory工厂
                sessionFactory = config.buildSessionFactory();
    }
    //获得全新得session
    public static Session getSession(){
        
        //获取session
        Session session = sessionFactory.openSession();
        return  session;
        
    }
    
    //
    public static Session getCurrentSession(){
        
        
        return sessionFactory.getCurrentSession();
    }
}

View Code

(7)HQL与Criteria与SQL

HQL

基本查询

package com.dao;

import java.util.List;

import org.hibernate.Session;
import org.hibernate.Transaction;
import org.hibernate.query.Query;

import com.domain.User;
import com.utils.HibernateUtils;

public class HQLDao {
    //测试基本查询
    public void serach(){
        Session session = HibernateUtils.getSession();
        Transaction beginTransaction = session.beginTransaction();
        
        /////////////////////////////
        //操作select * from user
        String hql="from com.domain.User";
        Query query = session.createQuery(hql);
        List<User> list = query.list();//查询多条数据
        //User user = (User)query.uniqueResult();//查询唯一的数据
        System.out.println(list);
        ///////////////////////////////////////
        beginTransaction.commit();
        session.close();
    }
}

View Code

package com.service;

import org.hibernate.Session;
import org.hibernate.Transaction;

import com.dao.HQLDao;
import com.dao.UserDao;
import com.domain.User;
import com.utils.HibernateUtils;

public class UserService {

    
    public void test(){
        HQLDao dao=new HQLDao();
        dao.serach();
    }
    public void addUser(User user) {
        UserDao dao=new UserDao();
        //开启事务
        Session currentSession = HibernateUtils.getCurrentSession();
        Transaction beginTransaction = currentSession.beginTransaction();
        try{
            //根据查找tuser
            //dao.addUser();
            User tuser=dao.findUserById("1");
            if(tuser!=null){
                //如果找到了，根据id修改名字
                dao.ChangeUserByUserId(tuser.getId());
            }
            else{
                
            }
        }catch(Exception e){
            e.printStackTrace();
            //事务的回滚
            beginTransaction.rollback();
        }
        
        //提交事务
        beginTransaction.commit();
    }

}

View Code

package com.web;

import java.util.UUID;

import com.domain.User;
import com.opensymphony.xwork2.ActionSupport;
import com.opensymphony.xwork2.ModelDriven;
import com.service.UserService;

public class UserAction extends ActionSupport implements ModelDriven<User>{

    
    User user=new User();
    public String register() throws Exception {
        //user.setId(UUID.randomUUID().toString());
        UserService userService=new UserService();
        userService.test();
        
        return "tologin";
    }

    
    public User getModel() {
        // TODO Auto-generated method stub
        return user;
    }
    
}

View Code

条件查询

基本条件查询

String hql="from com.domain.User where id=?0";

query.setParameter(0, id);

?占位符

String hql="from com.domain.User where id=?0";

命名占位符

String hql="from com.domain.User where id=:id";

/ /设置参数
query.setParameter("id", id);

分页查询

limit ?,?

String hql="from user com.domain.User";

query.setFirstResult(0);
query.setMaxResults(1);

package com.dao;

import java.util.List;

import org.hibernate.Session;
import org.hibernate.Transaction;
import org.hibernate.query.Query;

import com.domain.User;
import com.utils.HibernateUtils;

public class HQLDao {
    //测试基本查询
    public void serach(){
        Session session = HibernateUtils.getSession();
        Transaction beginTransaction = session.beginTransaction();
        
        /////////////////////////////
        //操作select * from user
        String hql="from com.domain.User";
        Query query = session.createQuery(hql);
        List<User> list = query.list();//查询多条数据
        //User user = (User)query.uniqueResult();//查询唯一的数据
        System.out.println(list);
        ///////////////////////////////////////
        beginTransaction.commit();
        session.close();
    }
    //条件查询
    public void serach1(){
        Session session = HibernateUtils.getSession();
        Transaction beginTransaction = session.beginTransaction();
        
        /////////////////////////////
        //操作select * from user where id=1;
        String hql="from com.domain.User where id=1";
        Query query = session.createQuery(hql);
        User user = (User)query.uniqueResult();
        System.out.println(user);
        ///////////////////////////////////////
        beginTransaction.commit();
        session.close();
    }
    //条件查询
        public void serach2(String id){
            Session session = HibernateUtils.getSession();
            Transaction beginTransaction = session.beginTransaction();
            
            /////////////////////////////
            //操作select * from user where id=?   user对象的id
            //sql语言完全面向对象的
            
            String hql="from com.domain.User where id=?0";
            Query query = session.createQuery(hql);
            //设置参数
            query.setParameter(0, id);
            //query.setString(0, id);
            User user =(User) query.uniqueResult();
            System.out.println(user.getPassword());
            ///////////////////////////////////////
            beginTransaction.commit();
            session.close();
        }
        //命名占位符查询
                public void serach3(String id){
                    Session session = HibernateUtils.getSession();
                    Transaction beginTransaction = session.beginTransaction();
                    
                    /////////////////////////////
                    //操作select * from user where id=?   user对象的id
                    //sql语言完全面向对象的
                    String hql="from com.domain.User where id=:id";
                    Query query=session.createQuery(hql);
                    //设置参数
                    query.setParameter("id", id);
                    User user=(User)query.uniqueResult();
                    System.out.println(user.getEmail());
                    
                    ///////////////////////////////////////
                    beginTransaction.commit();
                    session.close();
                }
                
                //命名占位符查询
                public void serach4(){
                    Session session = HibernateUtils.getSession();
                    Transaction beginTransaction = session.beginTransaction();
                    
                    /////////////////////////////
                    //操作select * from user limit 0,1;   user对象的id
                    //hql语言完全面向对象的
                    String hql="from user com.domain.User";
                    Query query = session.createQuery(hql);
                    query.setFirstResult(0);
                    query.setMaxResults(1);
                    List<User> list = query.list();
                    System.out.println(list.get(0).getUsername());
                    ///////////////////////////////////////
                    beginTransaction.commit();
                    session.close();
                }
                
}

View Code

Criteria

基本查询

条件查询

分页查询

查询总记录

package com.sikiedu.dao;

import java.util.List;

import javax.persistence.criteria.CriteriaBuilder;
import javax.persistence.criteria.CriteriaQuery;
import javax.persistence.criteria.Root;

import org.hibernate.Criteria;
import org.hibernate.SQLQuery;
import org.hibernate.Session;
import org.hibernate.Transaction;
import org.hibernate.criterion.Order;
import org.hibernate.query.NativeQuery;
import org.hibernate.query.Query;

import com.sikiedu.domain.User;
import com.sikiedu.utils.HibernateUtils;

public class CriteriaDao {

    // 基本查询
    public void search() {

        Session session = HibernateUtils.getSession();
        Transaction beginTransaction = session.beginTransaction();

        /////////////////////
        // 操作 select * from user

        CriteriaBuilder criteriaBuilder = session.getCriteriaBuilder();
        // createQuery-->查询条件(首先要知道查询什么类型数据)
        CriteriaQuery<User> createQuery = criteriaBuilder.createQuery(User.class);
        Root<User> from = createQuery.from(User.class);
        createQuery.select(from);
        
        
        // 执行查询
        List<User> resultList = session.createQuery(createQuery).getResultList();

        System.out.println(resultList);

        /////////////////////
        beginTransaction.commit();
        session.close();

    }

    // 条件查询
    public void search2() {

        Session session = HibernateUtils.getSession();
        Transaction beginTransaction = session.beginTransaction();

        /////////////////////
        // 操作 select * from user

        CriteriaBuilder criteriaBuilder = session.getCriteriaBuilder();

        // createQuery-->查询条件(首先要知道查询什么类型数据)
        CriteriaQuery<User> criteria = criteriaBuilder.createQuery(User.class);
        Root<User> root = criteria.from(User.class);
        criteria.select(root).where(root.get("id").in("1"));
        // 执行查询
        List<User> resultList = session.createQuery(criteria).getResultList();

        System.out.println(resultList);

        /////////////////////
        beginTransaction.commit();
        session.close();

    }

    // 查询总数查询
    public void search3() {

        Session session = HibernateUtils.getSession();
        Transaction beginTransaction = session.beginTransaction();

        /////////////////////
        // 操作 select count(*) from user

        CriteriaBuilder criteriaBuilder = session.getCriteriaBuilder();

        // createQuery-->查询条件(首先要知道查询什么类型数据)(数Integer Long)
        CriteriaQuery<Long> criteria = criteriaBuilder.createQuery(Long.class);
        Root<User> root = criteria.from(User.class);
        criteria.select(criteriaBuilder.count(root));
        
        // 执行查询
        Long count = session.createQuery(criteria).uniqueResult();
        
        System.out.println(count);

        /////////////////////
        beginTransaction.commit();
        session.close();

    }
    
    //查询名字带有i的人的总数 -- 2
    // 查询总数查询
    public void search4() {

        Session session = HibernateUtils.getSession();
        Transaction beginTransaction = session.beginTransaction();

        /////////////////////
        // 操作 select count(*) from user where username like '%i%'  
        
        CriteriaBuilder criteriaBuilder = session.getCriteriaBuilder();
        
        CriteriaQuery<Long> criteria = criteriaBuilder.createQuery(Long.class);
        Root<User> root = criteria.from(User.class);
        
        criteria.select(criteriaBuilder.count(root)).where(criteriaBuilder.like(root.get("username"), "%i%"));

    
        Long count = session.createQuery(criteria).uniqueResult();

        System.out.println(count);
        
        /////////////////////
        beginTransaction.commit();
        session.close();

    }
    

}

View Code

sql

基本查询

条件查询

分页查询

package com.dao;

import java.util.List;

import org.hibernate.Session;
import org.hibernate.Transaction;
import org.hibernate.query.NativeQuery;
import org.hibernate.query.Query;

import com.domain.User;
import com.utils.HibernateUtils;

public class SQLDao {

//sql基本查询
    public void fun(){
        Session session = HibernateUtils.getSession();
        Transaction beginTransaction = session.beginTransaction();
        ///////////////////////////////////////
        String sql="select  * from user2";
          //创建sql查询
        NativeQuery query = session.createSQLQuery(sql);
        //封装数据1
        query.addEntity(User.class);
        //接收list
        List<User> list=query.list();
        //接收单一返回值
        //query.uniqueResult();
        System.out.println(list.get(0).getUsername()+"---"+list.get(1).getUsername()+"--"+list.get(2).getUsername());
        ///////////////////////////////////////////
        beginTransaction.commit();
        session.close();
    }
    
    //sql条件查询
        public void fun2(){
            Session session = HibernateUtils.getSession();
            Transaction beginTransaction = session.beginTransaction();
            ///////////////////////////////////////
            String sql="select * from user where id= ?";
         NativeQuery query = session.createSQLQuery(sql);
            //给？赋值
         //从1开始
            query.setParameter(1, 3);
            query.addEntity(User.class);
            User user = (User)query.uniqueResult();
            System.out.println(user);
            ///////////////////////////////////////////
            beginTransaction.commit();
            session.close();
        }
        
        //sql分页查询
                public void fun3(){
                    Session session = HibernateUtils.getSession();
                    Transaction beginTransaction = session.beginTransaction();
                    ///////////////////////////////////////
                    String sql="select * from user limit ?,?";
                 NativeQuery query = session.createSQLQuery(sql);
                    //给？赋值
                 //从1开始
                    query.setParameter(1, 0);
                    query.setParameter(2, 2);
                    query.addEntity(User.class);
                    List<User> list = query.list();
                    System.out.println(list+"---"+list.get(0).getUsername()+"---"+list.get(1).getUsername());
                    ///////////////////////////////////////////
                    beginTransaction.commit();
                    session.close();
                }
}

View Code

(8)一对多/多对一

(9)多对多

相关阅读:
ReactiveCocoa -函数式编程和响应式编程
 关于即时通讯功能开发技术选型
 cordova 打包的项目里加入微信支付功能编译问题。
OC和swift互相调用。
有关 -all_load和-ObjC
在一个项目中同时使用Swift和Objective-C代码混合编程的方法
 iOS开发中Static和Const关键字的的作用
 开发所有插件必须要这个插件
 phonegap 二维码扫描插件使用
 大数据基础---Kafka深入理解分区副本机制
原文地址：https://www.cnblogs.com/wq-9/p/10884576.html

Hibernate

1.Hibernate初步了解

(1)什么是hibernate,hibernate是用来做什么的

2.使用c3p0与dbutils编写用户注册功能

所需jar包如下

所建包结构如下：

webconten目录如下：

主要代码如下

3.使用hibernate编写用户注册功能

4.对比这两种方式

5.学习hibernate(重点)

(1)hibernate配置文件的讲解

实体映射配置文件的讲解xxx.hbm.xml

主键生成策略5种

(2)api的讲解

1.Configuration

2.SessionFactory

(3)创建实体

(4)对象的三种状态

三种状态的转换

(5)一级缓存

(6)事务管理

事务的性质

事务的隔离级别

配置事务的隔离级别

使用事务小案例

(7)HQL与Criteria与SQL

HQL

Criteria

sql