精华内容
下载资源
问答
  • 1.Hibernate处理联合主键 如果在表中有两个列联合起来当主键,处理步骤如下 编写一个类(实现序列化接口),封装主键,并编写程序 PO内编写各个属性,包括主键类型 在映射文件内写明: <composite-id name=...

    本章代码
    https://github.com/MarsOu1998/WebGenerator

    1.Hibernate处理联合主键

    如果在表中有两个列联合起来当主键,处理步骤如下

    1. 编写一个类(实现序列化接口),封装主键,并编写程序
    2. PO内编写各个属性,包括主键类型
    3. 在映射文件内写明:
    <composite-id name="属性名" class="主键类名">
    	<key-property name="属性名" column="列名"/>
    	<key-property name="属性名" column="列名"/>
    <composite-id/>
    

    假设数据库内有一个UnionKey这个模型,里面有一张表叫做Student,Student表内是利用name和age作为联合主键的,查询步骤如下:

    编写PO.StudentPK.java:

    package PO;
    
    import java.io.Serializable;
    
    public class StudentPK implements Serializable {
        private String name;
        private int age;
    
    
        public String getName() {
            return name;
        }
    
        public void setName(String name) {
            this.name = name;
        }
    
        public int getAge() {
            return age;
        }
    
        public void setAge(int age) {
            this.age = age;
        }
    }
    

    把联合主键的属性单独写一个类,然后在Student.java里面把StudentPK作为一个属性写成JavaBean风格。

    Student.java:

    package PO;
    
    public class Student {
        private String sex;
        private StudentPK spk;
    
        public String getSex() {
            return sex;
        }
    
        public void setSex(String sex) {
            this.sex = sex;
        }
    
        public StudentPK getSpk() {
            return spk;
        }
    
        public void setSpk(StudentPK spk) {
            this.spk = spk;
        }
    }
    

    编写映射文件Student.hbm.xml:

    package PO;
    
    public class Student {
        private String sex;
        private StudentPK spk;
    
        public String getSex() {
            return sex;
        }
    
        public void setSex(String sex) {
            this.sex = sex;
        }
    
        public StudentPK getSpk() {
            return spk;
        }
    
        public void setSpk(StudentPK spk) {
            this.spk = spk;
        }
    }
    

    编写测试类test1.java:

    package Test;
    
    import PO.Student;
    import PO.StudentPK;
    import org.hibernate.Session;
    
    public class test1 {
        public static void main(String[] args) {
            Session session=util.HibernateSessionFactory.getSession();
            StudentPK studentPK=new StudentPK();
            studentPK.setName("小明");
            studentPK.setAge(17);
            Student student= (Student)session.get(Student.class,studentPK);
            System.out.println(student.getSex());
    
            util.HibernateSessionFactory.closeSession();
    
        }
    }
    

    这样就可以获取17岁的小明的性别了。

    主键生成策略generator

    generator:主键生成器,英文是发电机的意思。每个主键都必须定义相应的主键生成策略。它用来为持久化类实例生成唯一的标识。

    Hibernate内置的主键生成策略:

    1. assigned:由用户手工给一个值(例如账号由用户决定)
    2. increment:不用手工给值,由系统自动递增(这些只是Hibernate的策略)(比如在注册的时候,账号由系统给定的))

    首先在配置文件里面的generator需要从assigned改成increment,当然,前提是数据库里面的账号,类型应该是int,不然会报错:

    User.hbm.xml:

    <?xml version="1.0"?>
    <!DOCTYPE hibernate-mapping PUBLIC
            "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
            "http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">
    <hibernate-mapping>
        <class name="PO.User" table="user2">
            <id name="account" column="account">
                <generator class="increment"></generator>
            </id>
            <property name="password" column="password"></property>
            <property name="name" column="name"></property>
        </class>
    </hibernate-mapping>
    

    Insert1.java:

    package Test;
    
    import PO.User;
    import org.hibernate.Session;
    import org.hibernate.Transaction;
    
    public class Insert1 {
        public static void main(String[] args) {
            Session session=util.HibernateSessionFactory.getSession();
            User user=new User();
            user.setPassword("oushile");
            user.setName("张三之王");
            Transaction transaction=session.beginTransaction();
            session.save(user);
            transaction.commit();
            util.HibernateSessionFactory.closeSession();
        }
    }
    

    系统会自动去查询当前数据库内最大的账号,然后在最大的基础上加一,就是自动递增的账号了。

    1. identity:由数据库生成主键
    2. sequence:由数据库根据序列生成主键
    3. hilo:根据Hibernate特殊算法生成主键
    4. native:系统自动选择identity,sequence,hilo
    5. uuid.hex:hibernate利用uuid算法生成主键

    按照increment来生成主键

    1. 在数据库内定义一个整型主键
    2. 定义一个整型属性指向这个主键
    3. 为主键设置生成策略为increment
    4. 添加时,无需指定主键

    2.动态模型

    使用动态实体模型,可以不定义JavaBean:

    1. 在class标签中设置一个属性,entity-name=“实体名称” 并指明对应的表名
    2. 在每个property标签中,给定义一个type属性,指定该列对应的类型名称

    每次利用Hibernate对数据库进行一定的操作时,JavaBean都是必不可少的,但是又很形式化,所以可以利用动态模型去省掉JavaBean的操作。

    配置映射文件:

    <?xml version="1.0"?>
    <!DOCTYPE hibernate-mapping PUBLIC
            "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
            "http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">
    <hibernate-mapping>
        <class entity-name="User"  table="user2">
            <id name="account" column="account" type="java.lang.Integer">
                <generator class="increment"></generator>
            </id>
            <property name="password" column="password" type="java.lang.String"></property>
            <property name="name" column="name" type="java.lang.String"></property>
        </class>
    </hibernate-mapping>
    

    这里把class从类名改为随便一个名字,name变为了entity-name,因为是动态的模型,系统不认识每个变量的类型了,java是强类型类型语言,所以需要在每一个属性后面,声明类型。

    Insert2.java:

    package Test;
    
    import org.hibernate.Session;
    import org.hibernate.Transaction;
    
    import java.util.HashMap;
    
    public class Insert2 {
        public static void main(String[] args) {
            Session session=util.HibernateSessionFactory.getSession();
            //动态模型用HashMap容纳一个记录
            HashMap hashMap=new HashMap();
            hashMap.put("account",3);
            hashMap.put("password","oushile");
            hashMap.put("name","张三的儿子");
    
            Transaction transaction=session.beginTransaction();
            session.save("User",hashMap);
            transaction.commit();
    
            util.HibernateSessionFactory.closeSession();
        }
    }
    

    没了JavaBean,使用动态模型的时候就使用HashMap进行对象的存储。在save的时候指定动态模型的名字和HashMap的对象名即可。

    利用对象存在方式:HashMap进行访问

    get、load、save、saveOrUpdate、update

    展开全文
  • generator元素:表示了一个主键生成器,它用来为持久化类实例生成唯一的标识 。 &lt;?xml version="1.0" encoding="UTF-8"?&gt; &lt;!DOCTYPE hibernate-mapping PUBLIC "...

    一、在hibernate的实体映射配置文件中配置hibernate的主键生成器:

    generator元素:表示了一个主键生成器,它用来为持久化类实例生成唯一的标识 。

    
    <?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.hibernate.entity.User" table="t_hibernate_user">
            <!-- name:指的是类属性   type: 类属性的类型      column: 对应表的对应列  -->
    	<!-- id标签对应的为表示列 -->
    	<id name="id" type="java.lang.Integer" column="id">
    	    <!-- 配置数据库的主键生成策略 -->
    	    <generator class="increment"></generator>		
            </id>
     
            <!-- name:指的是类属性   type: 类属性的类型      column: 对应表的对应列  -->
            <property name="" type="" column=""></property> 
            <!-- property 标签的个数与实体类中的属性相对应 -->
               ......
        </class>
    </hibernate-mapping>

    generator元素中的class属性可决定生成主键的类型:

    1、hibernate控制:

    incrementuuid/uuid.hex

    
    public static void main(String[] args) {
    		Configuration configure = new Configuration().configure("hibernate.cfg.xml");
    		SessionFactory sessionFactory = configure.buildSessionFactory();
    		Session session = sessionFactory.openSession();
    		Transaction transaction = session.beginTransaction();
     
                    /*
                     *  increment: 将主键生成策略设置为increment,即使数据库中的主键没有设置自增长,
                     *         hibernate也会为你维护主键,不过数据库中维护的主键的类型必须为数字类型
                     *  
                     *  uuid/uuid.hex: 也是hibernate帮你维护主键,主键类型必须为字符串类型
                     *
                     *
                     */
     
     
                    User user=new User();
    		user.setUser_name("张三");
                    session.save(user);
     
    		transaction.commit();
    		session.close();
    	}

    2、数据库控制:

    identity(标识列/自动增长)  、 sequence

    
    public static void main(String[] args) {
    		Configuration configure = new Configuration().configure("hibernate.cfg.xml");
    		SessionFactory sessionFactory = configure.buildSessionFactory();
    		Session session = sessionFactory.openSession();
    		Transaction transaction = session.beginTransaction();
     
                    /*
                     *  下面两种都是数据库自动维护的类型:
                     *  identity: 主键字段的类型为数字类型,且设置了自增长,否则会报错
                     *  
                     *  sequence: 当使用oracle数据库时,对于主键字段设置的序列进行维护
                     *
                     *
                     */
     
                    User user=new User();
    		user.setUser_name("张三");
                    session.save(user);
     
    		transaction.commit();
    		session.close();
    	}

    3、添加数据时手动设置:

    assigned

    
    public static void main(String[] args) {
    		Configuration configure = new Configuration().configure("hibernate.cfg.xml");
    		SessionFactory sessionFactory = configure.buildSessionFactory();
    		Session session = sessionFactory.openSession();
    		Transaction transaction = session.beginTransaction();
     
                    /*
                     *  数据类型不限、保存前设置的值,必须赋值
                     */
                    User user=new User();
    	        user.setId(999);
    		user.setUser_name("张三");
                    session.save(user);
     
    		transaction.commit();
    		session.close();
    	}

    4、自定义主键生成策略:

    下面新建了一个class:MyIncrement.java,实现 IdentifierGenerator接口,接口内有一个generate需要重写,

    这个方法返回的值即为我们想要主键自动生成的值

    
    package com.hibernate.util;
     
    import java.io.Serializable;
    import java.text.SimpleDateFormat;
    import java.util.Date;
     
    import org.hibernate.HibernateException;
    import org.hibernate.engine.spi.SharedSessionContractImplementor;
    import org.hibernate.id.IdentifierGenerator;
     
    public class MyIncrement implements IdentifierGenerator{
     
    	@Override
    	public Serializable generate(SharedSessionContractImplementor session, Object object) throws HibernateException {
    		return "my_test_"+new SimpleDateFormat("yyyy-MM-dd HH:mm:ss").format(new Date());
    	}
    }

    在实体映射的xml文件中将MyIncrement.java的全类名填入即可:

    <generator class="com.hibernate.util.MyIncrement"></generator>

     

    展开全文
  • 1. hibernate主键生成器: generator元素:表示了一个主键生成器,它用来为持久化类实例生 成唯一的标识 。 1.1 程序员自己控制:assigned 1.2 数据库控制: identity(标识列/自动增长) sequence 1.3 hibernate控制:...

    1. hibernate的主键生成器:
    generator元素:表示了一个主键生成器,它用来为持久化类实例生 成唯一的标识 。

    1.1 程序员自己控制:assigned

    1.2 数据库控制: identity(标识列/自动增长) sequence

    1.3 hibernate控制:increment uuid/uuid.hex

    1.4 其它:native

    2. 主键生成器要求
    2.1 assigned
    数据类型不限、保存前必须赋值

    2.2 identity(重点掌握)
    数字,无需赋值

    2.3 sequence(重点掌握)
    数字,无需赋值, 默认使hibernate_sequence这个序列,
    也可以通过sequence/sequence_name参数赋值

    2.4 increment
    数字,无需赋值

    2.5 uuid/uuid.hex (是由容器自动生成的一个32位的字符串,.hex代表的是十六进制)
    32位的字符串,无需赋值,

    2.6 native(重点掌握)
    等于identity+sequence

    3. 自定义主键生成器
    3.1 *.hbm.xml指定主键生成器类

    3.2 创建主键生成器类
    实现org.hibernate.id.IdentifierGenerator接口即可,并还可以实现org.hibernate.id.Configurable接口来读取一些配置信息
    PersistentIdentifierGenerator.TABLE
    PersistentIdentifierGenerator.PK

      assigned、native、自定义主键
    

    4.报错问题
    Exception in thread “main” org.hibernate.HibernateException: isConnected is not valid without active transaction

    Exception in thread “main” org.hibernate.HibernateException: Calling Method’isConnected’ id not valid without an active transaction(Current status:NOT:ACTIVE)

    两个错都是没有提交事务

    助手类的主要用途:
    配错控制台会报错:
    Caused by: org.hibernate.PropertyNotFoundException: Could not locate getter method for property [com.zking.one.entity.User#wid]
    如果映射有问题 就不会运行页面 控制台报错 一看就知道是xml的配置问题,这个就是典型的wid没有。

    展开全文
  • 一,概述 复合主键也是开发中经常遇到的需求,这篇博客就是关于复合主键映射,开始吧! 二,实体类准备 1)复合主键类 ... * 复合主键类:用户名和地址唯一标识一条记录 * * @author bighuan * */ public class

    一,概述

    复合主键也是开发中经常遇到的需求,这篇博客就是关于复合主键映射,开始吧!

    二,实体类准备

    1)复合主键类

    package com.bighuan.d_compositeKey;
    
    import java.io.Serializable;
    
    /**
     * 复合主键类:用户名和地址唯一标识一条记录
     * 
     * @author bighuan
     * 
     */
    public class CompositeKeys implements Serializable {
    
    	private String userName;
    	private String address;
    
    	public CompositeKeys() {
    
    	}
    
    	public String getUserName() {
    		return userName;
    	}
    
    	public void setUserName(String userName) {
    		this.userName = userName;
    	}
    
    	public String getAddress() {
    		return address;
    	}
    
    	public void setAddress(String address) {
    		this.address = address;
    	}
    
    }
    
    2)表对应的实体类User.java

    package com.bighuan.d_compositeKey;
    
    public class User {
    
    	public User() {
    
    	}
    
    	private int age;
    
    	private CompositeKeys keys;
    
    	public int getAge() {
    		return age;
    	}
    
    	public void setAge(int age) {
    		this.age = age;
    	}
    
    	public CompositeKeys getKeys() {
    		return keys;
    	}
    
    	public void setKeys(CompositeKeys keys) {
    		this.keys = keys;
    	}
    
    }
    

    三,配置文件准备

    1)User.java对应的映射文件User.hbm.xml

    <?xml version="1.0"?>
    <!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.bighuan.d_compositeKey"
    	auto-import="true">
    
    	<class name="User">
    		<!-- 复合主键映射 -->
    		<composite-id name="keys">
    			<key-property name="userName" type="string"></key-property>
    			<key-property name="address" type="string"></key-property>
    		</composite-id>
    
    		<property name="age" type="int"></property>
    
    	</class>
    
    </hibernate-mapping>
    
    配置复合主键主要是通过<composite-id>来完成!

    2)hibernate.cfg.xml(上一篇博客粘贴过这个文件,多复制一遍,加深印象)

    <!DOCTYPE hibernate-configuration PUBLIC
    	"-//Hibernate/Hibernate Configuration DTD 3.0//EN"
    	"http://www.hibernate.org/dtd/hibernate-configuration-3.0.dtd">
    
    <hibernate-configuration>
    	<session-factory>
    		<!--1, 数据库连接配置 -->
    		<property name="hibernate.connection.driver_class">com.mysql.jdbc.Driver</property>
    		<property name="hibernate.connection.url">jdbc:mysql://localhost:3306/hib_demo</property>
    		<property name="hibernate.connection.username">root</property>
    		<property name="hibernate.connection.password">abc</property>
    		
    		<!--2, 数据库方法配置:告诉hibernate使用的是什么数据库 -->
    		<!-- hibernate在运行的时候,会根据不同的方言生成符合当前数据库语法的sql -->
    		<property name="hibernate.dialect">org.hibernate.dialect.MySQL5Dialect</property>
    		<!--3, 其他相关配置:3.1展示hibernate在运行时执行的sql语句-->
    		<property name="hibernate.show_sql">true</property>
    		
    		<!-- 3.2格式化sql语句配置 -->
    		<property name="hibernate.format_sql">true</property>
    
                   <!-- 3.3自动建表 ,先删除后创建,不管有没有表-->
    		<!-- <property name="hibernate.hbm2ddl.auto">create</property> -->
    		
    		<!-- 3.4有表就不创建,反之就创建 -->
    		<property name="hibernate.hbm2ddl.auto">update</property> 
    		
    		<!--映射配置:  加载所有映射 -->
    		<mapping resource="com/bighuan/d_compositeKey/User.hbm.xml"/>
    	</session-factory>
    </hibernate-configuration>

    四,测试

    1)插入数据,查询数据

    package com.bighuan.d_compositeKey;
    
    import java.util.Date;
    
    import org.hibernate.SessionFactory;
    import org.hibernate.Transaction;
    import org.hibernate.cfg.Configuration;
    import org.junit.Test;
    
    public class App2 {
    
    	private static SessionFactory sf = null;
    	static {
    
    		sf = new Configuration().configure().buildSessionFactory();
    	}
    
    	@Test
    	public void testSave() throws Exception {
    		// 创建对象
    		CompositeKeys keys = new CompositeKeys();
    		keys.setUserName("bighuan");
    		keys.setAddress("江西南昌2");
    		User user = new User();
    		user.setAge(25);
    		user.setKeys(keys);
    
    		// 创建session(代表一个与数据库连接的会话)
    		org.hibernate.Session session = sf.openSession();
    		// 4,开启事务
    		Transaction tx = session.beginTransaction();
    		// 5,保存数据
    		session.save(user);
    
    		tx.commit();
    		// 7,关闭
    		session.close();
    	}
    
    	@Test
    	public void testQuery() throws Exception {
    		// 创建对象
    		CompositeKeys keys = new CompositeKeys();
    		keys.setUserName("bighuan");
    		keys.setAddress("江西南昌");
    
    		// 创建session(代表一个与数据库连接的会话)
    		org.hibernate.Session session = sf.openSession();
    		// 4,开启事务
    		Transaction tx = session.beginTransaction();
    		// 5,查询数据
    		User user = (User) session.get(User.class, keys);
    
    		if (user != null) {
    			System.out.println(user.getAge() + ","
    					+ user.getKeys().getAddress() + ","
    					+ user.getKeys().getUserName());
    		}
    
    		tx.commit();
    		// 7,关闭
    		session.close();
    	}
    
    }
    
    2)插入两条数据到数据库,数据库的user表

    3)通过主键查询

    25,江西南昌,bighuan


    展开全文
  • hibernate--主键生成

    2019-08-30 10:39:18
    1. hibernate主键生成器: generator元素:表示了一个主键生成器,它用来为持久化类实例生成唯一的标识 。 程序员自己控制:assigned 数据库控制: identity(标识列/自动增长) sequence hibernate...
  • hibernate中非主键标识列映射问题

    千次阅读 2012-05-30 23:39:13
    在使用hibernate的过程中,有很多人是先设计数据库的,出现一个问题就是非主键标示列如何映射,在用IDE映射到hibernate框架中的时候它将你的自增标识列(非主键)仅仅映射成一个普通的列, "-//Hibernate/...
  • 使用持久化注解(以JPA标准注解为主,如果有一些特殊要求,则依然需要使用Hibernate本身提供的注解)使用JPA2提供的XML配置描述文件,这种方式可以让Hibernate的PO类与JPA实体类兼容使用Hibernate传统的XML映射文件...
  • hibernate之复合主键

    2010-12-15 20:24:52
    对于系统设计而言,应该尽量减少和避免在数据库表中引入与业务逻辑相关的主键关系;将业务逻辑主键引入库表,使得底层数据库表结构与业务逻辑想耦合,如果业务逻辑的变化,将很可能对底层数据库结构产生连带应影响;...
  • Hibernate有很多值得学习的地方,这里我们主要介绍Hibernate主键,包括介绍Assigned方式、Increment方式和Foreign GUID等方面。 Hibernate主键介绍 1.Assigned Assigned方式由程序生成主键值,并且要在s
  • Hibernate的ID主键生成策略

    千次阅读 2014-10-08 16:18:05
    hibernate主键生成策略: 1>通过XML配置实现ID自动生成(测试uuid和native)。 2>通过注解配置实现ID自动生成。 3>通过XML配置实现联合主键。 4>通过注解配置实现联合主键(3种方式)。
  • 主键的生成策略第1种情况:整型字段sid主键的生成策略; 创建学生实体: package net.nw.vo; public class Student { private int sid; private String sname; public int getSid() { ...
  • 关于Hibernate修改数据库主键

    千次阅读 2012-02-14 19:13:42
    hibernate是根据ID来取出数据,保存也是根据ID。报错了:Batch update returned unexpected row count from update: 0 actual row count: 0 expected: 1。(主键设置为自增长,而在我们插入记录的时候设置了ID的值也...
  • 在java后台权限设置时需要使用联合主键来唯一标识权限 public class SystemPrivilegePK implements Serializable{ private static final long serialVersionUID = 1L; private SystemPrivilegePK id; ...
  • Hibernate主键生成策略主键生成策略主键生成器主键生成器要求自定义主键生成器demo 案例数据库表Util 工具类SessionFactoryUtilsxml 配置Student.hbm.xmlWorker.hbm.xml创建主键生成器类DemoDao 主键生成策略 ...
  • Result表中 TestID 与 StudentID构成联合主键 则在Result.hbm.xml中映射关系如下: 之后可能会报Serializable的错误,则在对应的类中实现Serializable接口,并添加如下代码即可。 public...
  • Hibernate之ID主键生成策略

    千次阅读 2012-08-09 22:50:03
    ID主键生成策略 一、 Xml方式 ...由一个字段构成主键,如果是...大多数类有一个JavaBeans风格的属性, 为每一个实例包含唯一的标识。 元素定义了该属性到数据库表主键字段的映射。 name="propertyName
  • Hibernate 中的主键生成

    2014-01-21 22:27:54
    很久没写这个博客了,囧~今天试了一下hibernate里面插入数据,使用currentSession,挺简单的方式: @Transactional @Override public Integer save(UserEntity user) { Integer in = (Integer) currentSession...
  • hibernate 关于主键

    2014-06-02 17:46:57
    1在xml中定义主键生成策略 其中class有多种类型 但实际上我们只需记得四种 native 自动选择数据库 identity 对DB2,MySQL, MS SQL Server, Sybase和HypersonicSQL的内置标识字段提供支持。 返回的标识符是long, ...
  • Hibernate的持久化类  什么是持久化类 1. 持久化类:就是一个Java类(咱们编写的JavaBean),这个Java类与表建立了映射关系就可以成为是持久化类。...2. 提供一个标识属性,映射数据表主键字段 -- 唯一标识...
  • Hibernate主键生成策略 1. hibernate主键生成器 generator元素:表示了一个主键生成器,它用来为持久化类实例生成唯一的标识 。 1.1 程序员自己控制:assigned 1.2 数据库控制: identity(标识列/自动增长) ...
  • Hibernate主键生成策略 1. hibernate主键生成器: generator元素:表示了一个主键生成器,它用来为持久化类实例生成唯一的标识 。 1.1 程序员自己控制:assigned 1.2 数据库控制: identity(标识列/自动增长) ...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 11,339
精华内容 4,535
关键字:

hibernatexml标识主键