he90227
he90227

一篇文章教你学会Hibernate

Hibernate实例入门


1、导入jar文件
    • 导入antlr-2.7.6.jar
    • 导入commons-collections-3.1.jar
    • 导入dom4j-1.6.1.jar
    • 导入hibernate-jpa-2.0-api-1.0.1.Final.jar
    • 导入hibernate3.jar
    • 导入javassist-3.12.0.GA.jar
    • 导入jta-1.1.jar
    • 导入mysql-connector-java-3.1.13-bin.jar
    • 导入slf4j-api-1.6.1.jar 

这一部分没有过多的解释，只需要大家了解每个jar文件包的作用即可。 

 

2、编辑实体 

[java]  view plain copy
  1. package com.entity;    
  2.     
  3. import java.util.Date;    
  4.     
  5. public class User {    
  6.     
  7.     private String id;      
  8.     private String name;        
  9.     private String password;        
  10.     private Date createTime;        
  11.     private Date expireTime;    
  12.     
  13.     public String getId() {    
  14.         return id;    
  15.     }    
  16.     public void setId(String id) {    
  17.         this.id = id;    
  18.     }     
  19.     public String getName() {    
  20.         return name;    
  21.     }     
  22.     public void setName(String name) {    
  23.         this.name = name;    
  24.     }     
  25.     public String getPassword() {    
  26.         return password;    
  27.     }     
  28.     public void setPassword(String password) {    
  29.         this.password = password;    
  30.     }      
  31.     public Date getCreateTime() {    
  32.         return createTime;    
  33.     }      
  34.     public void setCreateTime(Date createTime) {    
  35.         this.createTime = createTime;    
  36.     }    
  37.     
  38.     public Date getExpireTime() {    
  39.         return expireTime;    
  40.     }      
  41.     public void setExpireTime(Date expireTime) {    
  42.         this.expireTime = expireTime;    
  43.     }    
  44. } 

 

3、创建数据库、表

创建数据库 

说明: http://img.blog.csdn.net/20130616175235015

创建表 

一篇文章教你学会Hibernate_第1张图片

显示表结构

一篇文章教你学会Hibernate_第2张图片

 

这一步就是一个创建数据库的过程，与我们平常做项目使用的数据库结构和过程也没有区别。 

 

4、创建实体映射文件User.hbm.xml

[html]  view plain copy
  1. <?xml version="1.0"?>    
  2. <!DOCTYPE hibernate-mapping PUBLIC     
  3.     "-//Hibernate/Hibernate Mapping DTD 3.0//EN"    
  4.     "http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">    
  5. <hibernate-mapping>    
  6.     <class name="com.entity.User">    
  7.         <id name="id">    
  8.             <generator class="uuid"/>    
  9.         </id>    
  10.         <property name="name"/>    
  11.         <property name="password"/>    
  12.         <property name="createTime"/>    
  13.         <property name="expireTime"/>    
  14.     </class>    
  15. </hibernate-mapping>    


User.hbm.xml的作用简而言之就是对实体和数据库中的表进行相呼应，保证我们对实体对象进行的操作都会在数据库中产生与之对应响应的结果。但仅这样的配置还有一个问题那就是我们如何将能够将数据库中的表与对象进行关联。这就需要接下来的配置了。  


5、创建数据库连接和映射配置文件 hibernate.cfg.xml

[html]  view plain copy
  1. <!DOCTYPE hibernate-configuration PUBLIC    
  2.     "-//Hibernate/Hibernate Configuration DTD 3.0//EN"    
  3.     "http://hibernate.sourceforge.net/hibernate-configuration-3.0.dtd">    
  4.     
  5. <hibernate-configuration>    
  6.     <session-factory>    
  7.         <property name="hibernate.connection.driver_class">com.mysql.jdbc.Driver</property>    
  8.         <property name="hibernate.connection.url">jdbc:mysql://localhost:3306/hibernate_first</property>    
  9.         <property name="hibernate.connection.username">root</property>    
  10.         <property name="hibernate.connection.password">root</property>    
  11.         <property name="hibernate.dialect">org.hibernate.dialect.MySQLDialect</property>    
  12.         <property name="hibernate.show_sql">true</property>    
  13.          
  14.         <mapping resource="com/entity/User.hbm.xml"/>    
  15.     </session-factory>    
  16. </hibernate-configuration>   

这里的重点区别在于，通过映射说明<mapping resource="com/entity/User.hbm.xml"/>我们可以将数据库连接和映射进行联系，也就是说通过 hibernate.cfg.xml的配置，我们就可以找到具体的实体和数据库表对应关系。


6、创建测试文件 Client.java 

[java]  view plain copy
  1. package test;    
  2.     
  3. import java.util.Date;    
  4.     
  5. import org.hibernate.Session;    
  6. import org.hibernate.SessionFactory;    
  7. import org.hibernate.cfg.Configuration;    
  8.     
  9. import com.entity.User;    
  10.     
  11. public class Client {    
  12.     
  13.     public static void main(String[] args) {    
  14.             
  15.         //读取hibernate.cfg.xml文件    
  16.         Configuration cfg = new Configuration().configure();    
  17.             
  18.         //建立SessionFactory    
  19.         SessionFactory factory = cfg.buildSessionFactory();    
  20.             
  21.         //取得session    
  22.         Session session = null;    
  23.         try {    
  24.             session = factory.openSession();    
  25.             //开启事务    
  26.             session.beginTransaction();    
  27.             User user = new User();    
  28.             user.setName("NAME1");    
  29.             user.setPassword("PWD1");    
  30.             user.setCreateTime(new Date());    
  31.             user.setExpireTime(new Date());    
  32.                 
  33.             //保存User对象    
  34.             session.save(user);    
  35.                 
  36.             //提交事务    
  37.             session.getTransaction().commit();    
  38.         }catch(Exception e) {    
  39.             e.printStackTrace();    
  40.             //回滚事务    
  41.             session.getTransaction().rollback();    
  42.         }finally {    
  43.             if (session != null) {    
  44.                 if (session.isOpen()) {    
  45.                     //关闭session    
  46.                     session.close();    
  47.                 }    
  48.             }    
  49.         }    
  50.     }    
  51. }   

程序执行结果如下： 

一篇文章教你学会Hibernate_第3张图片

 

      我们向数据库中添加一个对象只需要通过HibernateAPI中最核心的Session接口，调用save()方法即可，不需要我们在代码中编写SQL语句，也不需要程序员对SQL语言过多的了解，这就体现了Hibernate完全面向对象编程。



Hibernate框架的使用步骤：
1、创建Hibernate的配置文件
 2、创建持久化类，即其实例需要保存到数据库中的类
 3、创建对象-关系映射文件

4、通过Hibernate API编写访问数据库的代码


Hibernate配置文件

        本此博文，我们重点讲解一下Hibernate的配置文件。Hibernate配置文件从形式来讲有两种主要的格式:一种是Java属性文件，即*.properties，这种配置格式主要定义连接各种数据库需要的参数；还有一种是XML格式的文件，这种文档除了可以定义连接各种数据库需要的参数，还可以定义程序中用的映射文件。所以一般情况下使用XML格式的配置文档。

properties形式的配置文件
         properties形式的配置文件默认文件名是hibernate.properties，一个properties形式的配置文件内容如下所示：
[plain]  view plain copy
  1. #指定数据库使用的驱动类  
  2. hibernate.connection.driver_class = com.mysql.jdbc.Driver  
  3. #指定数据库连接串  
  4. hibernate.connection.url = jdbc:mysql://localhost:3306/hibernate_first  
  5. #指定数据库连接的用户名  
  6. hibernate.connection.username = user  
  7. #指定数据库连接的密码  
  8. hibernate.connection.password = password  
  9. #指定数据库使用的方言  
  10. hibernate.dialect = org.hibernate.dialect.MySQLDialect  
  11. #指定是否打印SQL语句  
  12. hibernate.show_sql=true   


XML格式的配置文件
        XML格式的配置文件的默认文件名为hibernate.cfg.xml，一个XML配置文件的示例如下所示：
[html]  view plain copy
  1. ＜?xml version='1.0' encoding='UTF-8'?＞  
  2.     <!DOCTYPE hibernate-configuration PUBLIC  
  3.     "-//Hibernate/Hibernate Configuration DTD 3.0//EN"  
  4.     "http://hibernate.sourceforge.net/hibernate-configuration-3.0.dtd">  
  5.   
  6.   
  7.     <hibernate-configuration>  
  8.         <session-factory>  
  9.             ＜!--数据库驱动--＞  
  10.             <property name="hibernate.connection.driver_class">com.mysql.jdbc.Driver</property>  
  11.             ＜!--连接字符串--＞  
  12.             <property name="hibernate.connection.url">jdbc:mysql://localhost:3306/hibernate_first</property>  
  13.             ＜!--连接数据库的用户名--＞  
  14.             <property name="hibernate.connection.username">user</property>  
  15.             ＜!--数据库用户密码--＞  
  16.             <property name="hibernate.connection.password">root</property>  
  17.             ＜!--选择使用的方言--＞  
  18.             <property name="hibernate.dialect">org.hibernate.dialect.MySQLDialect</property>  
  19.             ＜!--显示执行的SQL语句--＞  
  20.             <property name="hibernate.show_sql">true</property>  
  21.               
  22.             ＜!--映射文件 --＞  
  23.             <mapping resource="com/zs/hibernate/User.hbm.xml"/>  
  24.         </session-factory>  
  25.     </hibernate-configuration>  

        properties形式的配置文件和XML格式的配置文件可以同时使用。当同时使用两种类型的配置文件时，XML配置文件中的设置会覆盖properties配置文件的相同的属性。


两种配置文件的主要区别就是XML可以配置映射。这里提到的映射即对象关系映射(Object Relational Mapping)。ORM的实现目的就是将对象数据保存到数据库中，同时可以将数据库数据读入对象中，这样开发人员就可以将对数据库数据的操作转化为对这些对象的操作。

基本映射

       了解了映射的意义和概念之后，我们来讲解一下映射的分类。从映射的概念来看，单个的数据库表可以映射成为一个对象，抛开Hibernate不谈，这种思路在很多项目开发中时常见的，即根据表结构创建相应实体类，这种简单的映射关系在Hibernate映射中被称为基本映射。

基本映射实例

如下图所示的表结构：

一篇文章教你学会Hibernate_第4张图片


经过转换之后，可以创建相应的对象，代码如下:

[java]  view plain copy
  1. public class User{  
  2.     private String id;    
  3.     private String name;  
  4.       
  5.     public String getId() {  
  6.         return id;  
  7.     }  
  8.     public void setId(String id) {  
  9.         this.id = id;  
  10.     }  
  11.     public String getName() {  
  12.         return name;  
  13.     }  
  14.     public void setName(String name) {  
  15.         this.name = name;  
  16.     }  
  17. }  

对于Hibernate来讲，仅仅是有上面的还是不够的，还需要一个XML格式的映射文件User.hbm.xml，代码如下:
[html]  view plain copy
  1. <?xml version="1.0"?>  
  2. <!DOCTYPE hibernate-mapping PUBLIC   
  3.     "-//Hibernate/Hibernate Mapping DTD 3.0//EN"  
  4.     "http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">  
  5. <hibernate-mapping package="com.zs.hibernate">  
  6.     <class name="User1" table="t_user1">  
  7.         <id name="id" column="user_id" length="32" access="field">  
  8.             <generator class="uuid"/>  
  9.         </id>  
  10.         <property name="name" length="30" unique="true" not-null="true"/>               
  11.     </class>  
  12. </hibernate-mapping>  

注解配置基本映射实例

除了上述XML方式配置映射外，还可以通过给类文件添加注解的方式配置映射，具体代码如下:
[java]  view plain copy
  1. @Entity  
  2. @Table(name="t_user")  
  3. public class User{  
  4.     @Id  
  5.     private String id;    
  6.     @GeneratedValue  
  7.     private String name;  
  8.       
  9.     public String getId() {  
  10.         return id;  
  11.     }  
  12.     public void setId(String id) {  
  13.         this.id = id;  
  14.     }  
  15.     public String getName() {  
  16.         return name;  
  17.     }  
  18.     public void setName(String name) {  
  19.         this.name = name;  
  20.     }  
  21. }  


关系映射分类

       关系映射即在基本映射的基础上处理多个相关对象和多个相关表之间联系的映射。关系映射从对应关系的角度可以分为如下七种类型：
一对一单向关联
一对一双向关联
一对多单向关联
多对一单向关联
一对多双向关联
多对多单向关联

多对多双向关联

       接下来博客，我们会分别讲解一下这七种关系映射。今天我们只讲其中的一对一单向关联。


一对一单向关联

       一对一单向关联从对象的角度分析，即在一个对象(Person)中存在另一个对象(IdCard)的引用，而在另一个对象(IdCard)中则不存在该对象(Person)的引用，这样就可以在加载该对象(Person)的时候找到另一个对象(IdCard)。
类结构图如下所示：

具体代码如下所示：

[java]  view plain copy
  1. public class Person {  
  2.     private int id;           
  3.     private String name;              
  4.     private IdCard idCard;  
  5.       
  6.     public int getId() {  
  7.         return id;  
  8.     }  
  9.     public void setId(int id) {  
  10.         this.id = id;  
  11.     }  
  12.     public String getName() {  
  13.         return name;  
  14.     }  
  15.     public void setName(String name) {  
  16.         this.name = name;  
  17.     }  
  18.     public IdCard getIdCard() {  
  19.         return idCard;  
  20.     }  
  21.     public void setIdCard(IdCard idCard) {  
  22.         this.idCard = idCard;  
  23.     }  
  24. }  
  25.   
  26. public class IdCard {             
  27.     private int id;           
  28.     private String cardNo;  
  29.     public int getId() {  
  30.         return id;  
  31.     }  
  32.     public void setId(int id) {  
  33.         this.id = id;  
  34.     }  
  35.     public String getCardNo() {  
  36.         return cardNo;  
  37.     }  
  38.     public void setCardNo(String cardNo) {  
  39.         this.cardNo = cardNo;  
  40.     }  
  41. }  

上述类结构的相应根据关联的策略不同会生成不同的表结构，可以分为主键关联和唯一外键关联。

主键关联

主键关联表结构如下:
一篇文章教你学会Hibernate_第5张图片


可以看出，主键关联即利用主键进行关联，关联主键的值相同。其相应的*.hbm.xml配置文件代码如下:

[html]  view plain copy
  1. <class name="com.zs.hibernate.IdCard" table="t_idCard">  
  2.     <id name="id">  
  3.         <generator class="native"/>  
  4.     </id>  
  5.     <property name="cardNo"/>  
  6. </class>  
  7.   
  8. <class name="com.zs.hibernate.Person" table="t_person">  
  9.     <id name="id">                          
  10.         <generator class="foreign">                             
  11.             <param name="property">idCard</param>  
  12.         </generator>  
  13.     </id>  
  14.     <property name="name"/>  
  15.     <one-to-one name="idCard" constrained="true"/>  
  16. </class>                                    

唯一外键关联

唯一外键关联表结构如下:
一篇文章教你学会Hibernate_第6张图片


       与主键关联所不同，唯一外键关联除主键外，在其一对一的指向端(Person)存在一个唯一外键，该唯一外键与被指向端(IdCard)相关联，关联主键的值相同。其相应的*.hbm.xml配置文件代码如下:

[html]  view plain copy
  1. <class name="com.zs.hibernate.IdCard" table="t_idCard">  
  2.     <id name="id">  
  3.         <generator class="native"/>  
  4.     </id>  
  5.     <property name="cardNo"/>  
  6. </class>  
  7.   
  8. <class name="com.zs.hibernate.Person" table="t_person">  
  9.     <id name="id">  
  10.         <generator class="native"/>  
  11.     </id>  
  12.     <property name="name"/>  
  13.     <many-to-one name="idCard" unique="true"/>  
  14. </class>  


一对一双向关联

       与一对一单向关联映射所不同的的是在一对一双向关联中，不但在一个对象(Person)中存在另一个对象(IdCard)的引用，而在另一个对象(IdCard)中也存在对该对象(Person)的引用，这样即可以在加载该对象(Person)的时候找到另一个对象(IdCard)，也可以在加载另一个对象(IdCard)的时候找到该对象(Person)。

类结构图如下所示:

一篇文章教你学会Hibernate_第7张图片
具体代码如下所示:
[java]  view plain copy
  1. public class Person {  
  2.     private int id;           
  3.     private String name;              
  4.     private IdCard idCard;  
  5.       
  6.     public int getId() {  
  7.         return id;  
  8.     }  
  9.     public void setId(int id) {  
  10.         this.id = id;  
  11.     }  
  12.     public String getName() {  
  13.         return name;  
  14.     }  
  15.     public void setName(String name) {  
  16.         this.name = name;  
  17.     }  
  18.     public IdCard getIdCard() {  
  19.         return idCard;  
  20.     }  
  21.     public void setIdCard(IdCard idCard) {  
  22.         this.idCard = idCard;  
  23.     }  
  24. }  
  25.   
  26. public class IdCard {         
  27.     private int id;       
  28.     private String cardNo;        
  29.     private Person person;  
  30.       
  31.     public int getId() {  
  32.         return id;  
  33.     }  
  34.     public void setId(int id) {  
  35.         this.id = id;  
  36.     }  
  37.     public String getCardNo() {  
  38.         return cardNo;  
  39.     }  
  40.     public void setCardNo(String cardNo) {  
  41.         this.cardNo = cardNo;  
  42.     }  
  43.     public Person getPerson() {  
  44.         return person;  
  45.     }  
  46.     public void setPerson(Person person) {  
  47.         this.person = person;  
  48.     }  
  49. }  

       与一对一单向关联映射相同，一对一双向关联映射同样关联的策略不同会生成不同的表结构，也可以分为主键关联和唯一外键关联。但与一对一单向关联映射相同的是生成的表结构，即一对一双向关联映射与一对一单向关联相比，只是改变了一对一关联映射的加载，并没有改变存储。

主键关联

主键关联表结构如下:
一篇文章教你学会Hibernate_第8张图片
       同一对一单向关联映射类似，主键关联即利用主键进行关联，关联主键的值相同。其相应的*.hbm.xml配置文件代码如下:
[html]  view plain copy
  1. <class name="com.zs.hibernate.IdCard" table="t_idCard">  
  2.     <id name="id">  
  3.         <generator class="native"/>  
  4.     </id>  
  5.     <property name="cardNo"/>  
  6.     <one-to-one name="person"/>  
  7. </class>  
  8.   
  9. <class name="com.zs.hibernate.Person" table="t_person">  
  10.     <id name="id">  
  11.         <generator class="foreign">  
  12.             <param name="property">idCard</param>  
  13.         </generator>  
  14.     </id>  
  15.     <property name="name"/>                     
  16.     <one-to-one name="idCard" constrained="true"/>  
  17. </class>  

唯一外键关联

唯一外键关联表结构如下:

一篇文章教你学会Hibernate_第9张图片

        一对一双向关联映射的外键关联映射也与一对一单向关联映射的外键关联映射类似，在其一对一的指向端(Person)存在一个唯一外键，该唯一外键与被指向端(IdCard)相关联，关联主键的值相同。其相应的*.hbm.xml配置文件代码如下:
[html]  view plain copy
  1. <class name="com.zs.hibernate.IdCard" table="t_idCard">  
  2.     <id name="id">  
  3.         <generator class="native"/>  
  4.     </id>  
  5.     <property name="cardNo"/>  
  6.     <one-to-one name="person" property-ref="idCard"/>  
  7. </class>  
  8.   
  9. <class name="com.zs.hibernate.Person" table="t_person">  
  10.     <id name="id">  
  11.         <generator class="native"/>  
  12.     </id>  
  13.     <property name="name"/>  
  14.     <many-to-one name="idCard" unique="true"/>  
  15. </class>  
       同样利用在类文件中注解的方式也可以取代XML配置映射。



多对一单向关联映射

       多对一关联映射与一对一关联映射类似，只是在多对一的指向端可以存在多个对象，在指向端加载的时候，同时加载被指向端。

多对一和一对一的异同

       对比一对一单向关联映射和多对一单向关联映射，两者的相同之处在于在指向端被加载的时候，被指向端会被一起加载进来，这一点从如下类的结构图和代码中看出。(以下只给出多对一相关图示和代码，一对一图示和代码参考之前的文章Hibernate从入门到精通（五）一对一单向关联映射)

一篇文章教你学会Hibernate_第10张图片


[java]  view plain copy
  1. public class Group {  
  2.     private int id;           
  3.     private String name;  
  4.     public int getId() {  
  5.         return id;  
  6.     }  
  7.     public void setId(int id) {  
  8.         this.id = id;  
  9.     }  
  10.     public String getName() {  
  11.         return name;  
  12.     }  
  13.     public void setName(String name) {  
  14.         this.name = name;  
  15.     }  
  16. }  
  17.   
  18. public class User {  
  19.     private int id;           
  20.     private String name;              
  21.     private Group group;  
  22.     public int getId() {  
  23.         return id;  
  24.     }  
  25.     public void setId(int id) {  
  26.         this.id = id;  
  27.     }  
  28.     public String getName() {  
  29.         return name;  
  30.     }  
  31.     public void setName(String name) {  
  32.         this.name = name;  
  33.     }  
  34.     public Group getGroup() {  
  35.         return group;  
  36.     }  
  37.     public void setGroup(Group group) {  
  38.         this.group = group;  
  39.     }  
  40. }  

           通过分析上述代码和类图结构，单纯的看两者区别不大。但是通过映射表结构的对比，两者的不同之处在于指向端一个与被指向端的关系，一对一单向关联是一对一关系，而多对一单向关联则是多对一关系。(以下只给出多对一相关图示和代码，一对一图示和代码参考之前的文章Hibernate从入门到精通（五）一对一单向关联映射)

一篇文章教你学会Hibernate_第11张图片


       通过上说说明，我们也可以简单说一对一单向关联其实是多对一单向关联的一种特殊情况，这一点从其Hibernate映射配置中可以更加明显看出。


多对一映射配置: 

[html]  view plain copy
  1. <class name="com.zs.hibernate.User" table="t_user">  
  2.     <id name="id">  
  3.         <generator class="native"/>  
  4.     </id>  
  5.     <property name="name"/>  
  6.     <many-to-one name="group" column="groupid" cascade="save-update"/>  
  7. </class>  
  8.   
  9. <class name="com.zs.hibernate.Group" table="t_group">  
  10.     <id name="id">  
  11.         <generator class="native"/>  
  12.     </id>  
  13.     <property name="name"/>  
  14. </class>  

一对一映射配置：

[html]  view plain copy
  1. <class name="com.zs.hibernate.Person" table="t_person">    
  2.     <id name="id">    
  3.         <generator class="native"/>    
  4.     </id>    
  5.     <property name="name"/>    
  6.     <many-to-one name="idCard" unique="true"/>    
  7. </class>   
  8. <class name="com.zs.hibernate.IdCard" table="t_idCard">    
  9.     <id name="id">    
  10.         <generator class="native"/>    
  11.     </id>    
  12.     <property name="cardNo"/>    
  13. </class>    

         我们从上面可以明显看出一对一只是在<many-to-one/> 标签中添加了unique="true"这样一个限制指向端的属性而已。



一对多单向关联映射

        在讲解一对多单向关联之前，按照我们的惯例首先看一下其相应的类结构图和代码。具体如下:

一篇文章教你学会Hibernate_第12张图片

[java]  view plain copy
  1. public class Classes {        
  2.     private int id;  
  3.     private String name;          
  4.     private Set students;  
  5.     public int getId() {  
  6.         return id;  
  7.     }  
  8.     public void setId(int id) {  
  9.         this.id = id;  
  10.     }  
  11.     public String getName() {  
  12.         return name;  
  13.     }  
  14.     public void setName(String name) {  
  15.         this.name = name;  
  16.     }  
  17.     public Set getStudents() {  
  18.         return students;  
  19.     }  
  20.     public void setStudents(Set students) {  
  21.         this.students = students;  
  22.     }         
  23. }  
  24.   
  25. public class Student {  
  26.     private int id;       
  27.     private String name;  
  28.     public int getId() {  
  29.         return id;  
  30.     }  
  31.     public void setId(int id) {  
  32.         this.id = id;  
  33.     }  
  34.     public String getName() {  
  35.         return name;  
  36.     }  
  37.     public void setName(String name) {  
  38.         this.name = name;  
  39.     }  
  40. }  

       对比一对多关联映射和我们之前讲的多对一关联映射，可以发现两种映射原理是一致的，都是在多的一端加入一个外键，指向一的一端。它们的区别在于维护的关系不同，多对一维护的是多指向一的关系，有了此关系，在加载多的时候可以将一加载上来，一对多维护的是一指向多的关系，有了此关系，在加载一的时候可以将多加载上来。

        为了更好说明上述的结论，我们再看一下一对多关联映射的表结构和相应的Hibernate映射配置。具体如下:
一篇文章教你学会Hibernate_第13张图片

[html]  view plain copy
  1. <class name="com.zs.hibernate.Classes" table="t_classes">  
  2.     <id name="id">  
  3.         <generator class="native"/>  
  4.     </id>  
  5.     <property name="name"/>  
  6.     <set name="students">  
  7.          <key column="classesid"/>  
  8.         <one-to-many class="com.zs.hibernate.Student"/>  
  9.     </set>  
  10. </class>  
  11.   
  12. <class name="com.zs.hibernate.Student" table="t_student">  
  13.     <id name="id">  
  14.         <generator class="native"/>  
  15.     </id>  
  16.     <property name="name"/>  
  17. </class>  


        通过上面表中数据和我们之前关于多对一(参考Hibernate从入门到精通（七）多对一单向关联映射)的对比，我们就可以清晰的看出，在一对多中，仅仅添加了一个<set/>标签，将多对一中的一改为多而已，如果将集合看成一个整体，则两者实际上就没有区别了。


一对多单向关联映射缺陷

       到此为止，关于一对多单向关联基本，但是细心的读者可能发现了在一对多中的一的一端维护关系是有缺陷的。例如:在保存Student的时候关系字段classesid为null，则将无法保存数据等等。这些问题如何解决，这就需要引出我们下次讲解的一对多双向关联映射了。



一对多双向关联映射

       一对多双向关联映射，即在一的一端存在多的一端的一个集合对象，在多的一端存在一的一端的一个对象，这样就可以保证在加载一的一端或多的一端将被指向端的集合或对象加载上来，即保证双向关联。


一对多双向关联映射和一对多单向关联映射的异同

       一对多双向关联映射相应的类结构图和代码。具体如下:

一篇文章教你学会Hibernate_第14张图片

[java]  view plain copy
  1. public class Classes {    
  2.     private int id;   
  3.     private String name;      
  4.     private Set students;  
  5.       
  6.     public int getId() {  
  7.         return id;  
  8.     }  
  9.     public void setId(int id) {  
  10.         this.id = id;  
  11.     }  
  12.     public String getName() {  
  13.         return name;  
  14.     }  
  15.     public void setName(String name) {  
  16.         this.name = name;  
  17.     }  
  18.     public Set getStudents() {  
  19.         return students;  
  20.     }  
  21.     public void setStudents(Set students) {  
  22.         this.students = students;  
  23.     }     
  24. }  
  25.   
  26. public class Student {  
  27.     private int id;   
  28.     private String name;      
  29.     private Classes classes;  
  30.   
  31.     public int getId() {  
  32.         return id;  
  33.     }  
  34.     public void setId(int id) {  
  35.         this.id = id;  
  36.     }  
  37.     public String getName() {  
  38.         return name;  
  39.     }  
  40.     public void setName(String name) {  
  41.         this.name = name;  
  42.     }  
  43.     public Classes getClasses() {  
  44.         return classes;  
  45.     }  
  46.     public void setClasses(Classes classes) {  
  47.         this.classes = classes;  
  48.     }  
  49. }  

       通过对比之前我们在上篇博文Hibernate从入门到精通（八）一对多单向关联映射中的关于一对多单向关联映射的相应的类结构图和代码。可以发现，一对多双向关联向和单向关联的区别主要是在多的一端加入了一的一端的对象，这就将单向关联变成了双向关联。
       为了更好说明两者的区别，我们再看一下一对多双向关联映射的表结构和相应的Hibernate映射配置。具体如下:
一篇文章教你学会Hibernate_第15张图片

[html]  view plain copy
  1. <class name="com.zs.hibernate.Classes" table="t_classes">  
  2.     <id name="id">  
  3.         <generator class="native"/>  
  4.     </id>  
  5.     <property name="name"/>  
  6.     <set name="students" inverse="true">        
  7.         <key column="classesid"/>  
  8.         <one-to-many class="com.zs.hibernate.Student"/>  
  9.     </set>  
  10. </class>  
  11.   
  12. <class name="com.zs.hibernate.Student" table="t_student">  
  13.     <id name="id">  
  14.         <generator class="native"/>  
  15.     </id>  
  16.     <property name="name"/>  
  17.     <many-to-one name="classes" column="classesid"/>  
  18. </class>  

       从存储结构上看，一对多单向关联和双向关联没有什么区别，但是从配置文件上看，一对多双向关联的配置文件中在多的一端的配置文件上存在<many-to-one />的相关配置，即保证多对一的映射，这就保证了双向。


       通过本次的讲解，关于一对多双向关联的内容，我们就讲解完毕了，一对多映射是一个比较常用和重要的映射关系，




多对多单向关联映射

       在讲解多对多单向关联映射之前，首先看一下相关类图和代码，具体如下：
一篇文章教你学会Hibernate_第16张图片
[java]  view plain copy
  1. public class Role {  
  2.     private int id;   
  3.     private String name;  
  4.       
  5.     public int getId() {  
  6.         return id;  
  7.     }  
  8.     public void setId(int id) {  
  9.         this.id = id;  
  10.     }  
  11.     public String getName() {  
  12.         return name;  
  13.     }  
  14.     public void setName(String name) {  
  15.         this.name = name;  
  16.     }  
  17. }  
  18.   
  19. public class User {   
  20.     private int id;   
  21.     private String name;  
  22.     private Set roles;  
  23.       
  24.     public int getId() {  
  25.         return id;  
  26.     }  
  27.     public void setId(int id) {  
  28.         this.id = id;  
  29.     }  
  30.     public String getName() {  
  31.         return name;  
  32.     }  
  33.     public void setName(String name) {  
  34.         this.name = name;  
  35.     }  
  36.     public Set getRoles() {  
  37.         return roles;  
  38.     }  
  39.     public void setRoles(Set roles) {  
  40.         this.roles = roles;  
  41.     }  
  42. }  

多对多单向关联和一对多单向关联的异同

       多对多单向关联映射与一对多单向关联映射类似，都是在指向端被加载时，将被指向段加载上来，即单向的约束，所不同的是将一对多中一的一端从一变成了多而已，这点可以从类图上明显看出。但从代码上看一对多和多对多的区别则很难看出两者的区别。(参考Hibernate从入门到精通（八）一对多单向关联映射)

       接下来我们再从存储结构上分析两者的区别和联系。具体如下：

一篇文章教你学会Hibernate_第17张图片

一篇文章教你学会Hibernate_第18张图片

       通过上述表结构明显可以看出，在多对多关联映射中，存在第三张表，用以维护关联关系两端对象的对应关系，而这在一对多中则是不存在的。为什么会这样呢？这是因为配置文件的配置不同所导致的这样的映射结果。具体如下：

[html]  view plain copy
  1. <class name="com.zs.hibernate.User" table="t_user">  
  2.     <id name="id">  
  3.         <generator class="native"/>  
  4.     </id>  
  5.     <property name="name"/>  
  6.     <set name="roles" table="t_user_role">  
  7.         <key column="user_id"/>  
  8.         <many-to-many class="com.zs.hibernate.Role" column="role_id" />     
  9.     </set>  
  10. </class>  
  11.   
  12. <class name="com.zs.hibernate.Role" table="t_role">  
  13.     <id name="id">  
  14.         <generator class="native"/>  
  15.     </id>  
  16.     <property name="name"/>  
  17. </class>  

       通过对比上篇文章Hibernate从入门到精通（八）一对多单向关联映射中映射文件可以看出在一对多单向关联中映射配置的属性为<one-to-many/>，而多对多关联映射中配置的属性为<many-to-many/>，这就导致了映射的两种不同结果和两种不同的解决方案。




多对多双向关联映射

按照我们之前的惯例，先看一下相关类图和代码，具体如下：

一篇文章教你学会Hibernate_第19张图片

[java]  view plain copy
  1. public class Role {  
  2.     private int id;   
  3.     private String name;      
  4.     private Set users;  
  5.       
  6.     public int getId() {  
  7.         return id;  
  8.     }  
  9.     public void setId(int id) {  
  10.         this.id = id;  
  11.     }  
  12.     public String getName() {  
  13.         return name;  
  14.     }  
  15.     public void setName(String name) {  
  16.         this.name = name;  
  17.     }  
  18.     public Set getUsers() {  
  19.         return users;  
  20.     }  
  21.     public void setUsers(Set users) {  
  22.         this.users = users;  
  23.     }  
  24. }  
  25.   
  26. public class User {       
  27.     private int id;       
  28.     private String name;  
  29.     private Set roles;  
  30.       
  31.     public int getId() {  
  32.         return id;  
  33.     }  
  34.     public void setId(int id) {  
  35.         this.id = id;  
  36.     }  
  37.     public String getName() {  
  38.         return name;  
  39.     }  
  40.     public void setName(String name) {  
  41.         this.name = name;  
  42.     }  
  43.     public Set getRoles() {  
  44.         return roles;  
  45.     }  
  46.     public void setRoles(Set roles) {  
  47.         this.roles = roles;  
  48.     }  
  49. }  

       接下来我们对比之前的博文Hibernate从入门到精通（十）多对多单向关联映射中的多对多单向关联映射，来具体分析一下多对多双向关联映射，重点体会两者的区别和联系。

多对多双向与多对多单向关联映射的异同

       分析我们上述的类图和代码我们可以看出：单独看多对多双向关联的一端，多对多双向与多对多单向关联没有根本区别。只是在多对多的两端各有一个集合(Set),它用来存储与之相关的多个对象。(参考Hibernate从入门到精通（十）多对多单向关联映射)

       接下来我们从存储结构上看两者的区别，具体如下：

一篇文章教你学会Hibernate_第20张图片

一篇文章教你学会Hibernate_第21张图片



        从上图可以看出，多对多单向与双向的存储结构没有任何区别。接下来我们再来看一下配置信息。具体如下：

[html]  view plain copy
  1. <class name="com.zs.hibernate.Role" table="t_role">  
  2.     <id name="id">  
  3.         <generator class="native"/>  
  4.     </id>  
  5.     <property name="name"/>  
  6.     <set name="users" table="t_user_role">  
  7.         <key column="role_id" not-null="true"/>  
  8.         <many-to-many class="com.zs.hibernate.User" column="user_id"/>  
  9.     </set>  
  10. </class>  
  11.   
  12. <class name="com.zs.hibernate.User" table="t_user">  
  13.     <id name="id">  
  14.         <generator class="native"/>  
  15.     </id>  
  16.     <property name="name"/>  
  17.     <set name="roles" table="t_user_role">  
  18.         <key column="user_id" not-null="true"/>  
  19.         <many-to-many class="com.zs.hibernate.Role" column="role_id" />     
  20.     </set>  
  21. </class>  

        对比我们之前的博文Hibernate从入门到精通（十）多对多单向关联映射中的多对多单向映射的配置信息，我们可以看出在单向映射中，只能A->B,不能B->A，所以A与B的关系是不等的。而在双向关联映射中，既能A->B,也能B->A，所以A与B的关系是等价的。这样也就造成了在双向关联映射的配置文件的两个类的配置信息基本相同，即A=B。

1、导入jar文件
    • 导入antlr-2.7.6.jar
    • 导入commons-collections-3.1.jar
    • 导入dom4j-1.6.1.jar
    • 导入hibernate-jpa-2.0-api-1.0.1.Final.jar
    • 导入hibernate3.jar
    • 导入javassist-3.12.0.GA.jar
    • 导入jta-1.1.jar
    • 导入mysql-connector-java-3.1.13-bin.jar
    • 导入slf4j-api-1.6.1.jar 

这一部分没有过多的解释，只需要大家了解每个jar文件包的作用即可。 

 

2、编辑实体 

[java]  view plain copy
  1. package com.entity;    
  2.     
  3. import java.util.Date;    
  4.     
  5. public class User {    
  6.     
  7.     private String id;      
  8.     private String name;        
  9.     private String password;        
  10.     private Date createTime;        
  11.     private Date expireTime;    
  12.     
  13.     public String getId() {    
  14.         return id;    
  15.     }    
  16.     public void setId(String id) {    
  17.         this.id = id;    
  18.     }     
  19.     public String getName() {    
  20.         return name;    
  21.     }     
  22.     public void setName(String name) {    
  23.         this.name = name;    
  24.     }     
  25.     public String getPassword() {    
  26.         return password;    
  27.     }     
  28.     public void setPassword(String password) {    
  29.         this.password = password;    
  30.     }      
  31.     public Date getCreateTime() {    
  32.         return createTime;    
  33.     }      
  34.     public void setCreateTime(Date createTime) {    
  35.         this.createTime = createTime;    
  36.     }    
  37.     
  38.     public Date getExpireTime() {    
  39.         return expireTime;    
  40.     }      
  41.     public void setExpireTime(Date expireTime) {    
  42.         this.expireTime = expireTime;    
  43.     }    
  44. }  

这一步与普通的JDBC没有太大的区别，在JDBC中我们也可以通过实体封装需要的信息，如果你对面向对象编程有一定的了解相信不难理解。 

 

3、创建数据库、表

创建数据库 

说明: http://img.blog.csdn.net/20130616175235015

创建表 

一篇文章教你学会Hibernate_第22张图片

显示表结构

一篇文章教你学会Hibernate_第23张图片

 

这一步就是一个创建数据库的过程，与我们平常做项目使用的数据库结构和过程也没有区别。 

 

4、创建实体映射文件User.hbm.xml

[html]  view plain copy
  1. <?xml version="1.0"?>    
  2. <!DOCTYPE hibernate-mapping PUBLIC     
  3.     "-//Hibernate/Hibernate Mapping DTD 3.0//EN"    
  4.     "http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">    
  5. <hibernate-mapping>    
  6.     <class name="com.entity.User">    
  7.         <id name="id">    
  8.             <generator class="uuid"/>    
  9.         </id>    
  10.         <property name="name"/>    
  11.         <property name="password"/>    
  12.         <property name="createTime"/>    
  13.         <property name="expireTime"/>    
  14.     </class>    
  15. </hibernate-mapping>    


从这一步开始，JDBC开始与Hibernate有一定的区别，这里我们重点讲一下User.hbm.xml的作用。User.hbm.xml的作用简而言之就是对实体和数据库中的表进行相呼应，保证我们对实体对象进行的操作都会在数据库中产生与之对应响应的结果。但仅这样的配置还有一个问题那就是我们如何将能够将数据库中的表与对象进行关联。这就需要接下来的配置了。  


5、创建数据库连接和映射配置文件 hibernate.cfg.xml

[html]  view plain copy
  1. <!DOCTYPE hibernate-configuration PUBLIC    
  2.     "-//Hibernate/Hibernate Configuration DTD 3.0//EN"    
  3.     "http://hibernate.sourceforge.net/hibernate-configuration-3.0.dtd">    
  4.     
  5. <hibernate-configuration>    
  6.     <session-factory>    
  7.         <property name="hibernate.connection.driver_class">com.mysql.jdbc.Driver</property>    
  8.         <property name="hibernate.connection.url">jdbc:mysql://localhost:3306/hibernate_first</property>    
  9.         <property name="hibernate.connection.username">root</property>    
  10.         <property name="hibernate.connection.password">root</property>    
  11.         <property name="hibernate.dialect">org.hibernate.dialect.MySQLDialect</property>    
  12.         <property name="hibernate.show_sql">true</property>    
  13.          
  14.         <mapping resource="com/entity/User.hbm.xml"/>    
  15.     </session-factory>    
  16. </hibernate-configuration>   

这里的重点区别在于，通过映射说明<mapping resource="com/entity/User.hbm.xml"/>我们可以将数据库连接和映射进行联系，也就是说通过 hibernate.cfg.xml的配置，我们就可以找到具体的实体和数据库表对应关系。到此为止我们所有的配置就进行完毕了，接下来做一个测试。  


6、创建测试文件 Client.java 

[java]  view plain copy
  1. package test;    
  2.     
  3. import java.util.Date;    
  4.     
  5. import org.hibernate.Session;    
  6. import org.hibernate.SessionFactory;    
  7. import org.hibernate.cfg.Configuration;    
  8.     
  9. import com.entity.User;    
  10.     
  11. public class Client {    
  12.     
  13.     public static void main(String[] args) {    
  14.             
  15.         //读取hibernate.cfg.xml文件    
  16.         Configuration cfg = new Configuration().configure();    
  17.             
  18.         //建立SessionFactory    
  19.         SessionFactory factory = cfg.buildSessionFactory();    
  20.             
  21.         //取得session    
  22.         Session session = null;    
  23.         try {    
  24.             session = factory.openSession();    
  25.             //开启事务    
  26.             session.beginTransaction();    
  27.             User user = new User();    
  28.             user.setName("NAME1");    
  29.             user.setPassword("PWD1");    
  30.             user.setCreateTime(new Date());    
  31.             user.setExpireTime(new Date());    
  32.                 
  33.             //保存User对象    
  34.             session.save(user);    
  35.                 
  36.             //提交事务    
  37.             session.getTransaction().commit();    
  38.         }catch(Exception e) {    
  39.             e.printStackTrace();    
  40.             //回滚事务    
  41.             session.getTransaction().rollback();    
  42.         }finally {    
  43.             if (session != null) {    
  44.                 if (session.isOpen()) {    
  45.                     //关闭session    
  46.                     session.close();    
  47.                 }    
  48.             }    
  49.         }    
  50.     }    
  51. }   

程序执行结果如下： 

一篇文章教你学会Hibernate_第24张图片

 

       通过上述实例的演示，对比上一篇Hibernate从入门到精通（一）JDBC简介文章中我们提到的JDBC操作的缺陷可以看出，我们向数据库中添加一个对象只需要通过HibernateAPI中最核心的Session接口，调用save()方法即可，不需要我们在代码中编写SQL语句，也不需要程序员对SQL语言过多的了解，这就体现了Hibernate完全面向对象编程。

你可能感兴趣的:(Hibernate,简易Hibernate)

  • python简单好玩的编程代码,python有哪些好玩的代码 2301_81900439 pygamepython开发语言
    大家好，小编来为大家解答以下问题，20行python代码的入门级小游戏，python有什么好玩的代码嘛，今天让我们一起来看看吧！哈喽铁子们表弟最近在学Python，总是跟我抱怨很枯燥无味，其实，他有没有认真想过，可能是自己学习姿势不对？比方说，可以通过打游戏来学编程！今天给大家分享100个Python小游戏，一定要收藏！1、简易飞机大战飞机大战相信大家都玩过吧，非常简单有意思的游戏，咱们通过Pyt
  • 基于STM32的简易RTOS分析-预备知识 騏威 嵌入式
    写下这篇文章的主要目的是对自己学习RTOS的历程做一个记录和总结，方便以后回忆翻看。以下内容主要来自宋岩先生翻译的《Cortex-M3权威指南》。目录一、Cortex-M3寄存器简介二、堆栈操作简介三、汇编指令简介LDR和STR指令STMDB和LDMIA指令B、BX、BL、BLX指令MRS和MSR指令四、中断简介中断响应过程简介SVC和PensSV中断简介软件中断五、汇编基础一、Cortex-M3
  • 降伏不听话的静电，在家做一个富兰克林马达 三个爸爸实验室
    这是我们一起探索的第55个实验昨天我们一起认识了神奇的静电我们知道了通过摩擦可以产生静电我们也知道了有两种电荷一种是正电荷一种是负电荷如果两个正电荷相遇或者两个负电荷相遇他们会互相排斥如果是一个正电荷与一个负电荷相遇他们就会相互吸引今天我们就利用静电的这些特征做一个简易的马达由于美国科学家富兰克林对于静电研究非常多我们称这个马达为富兰克林马达一起来看一下怎么做的吧—富兰克林马达—三个爸爸实验室No
  • spring整合hibernate最基础的方式 木木ainiks hibernatespringjava
    1创建文件，可以创建web文件目录2导入jar包，需要导全，我就是jar没导全，后面怎么运行都不对3配置applicationContext.xml<beanid="sessionFactory"
  • netty-简易聊天 2401_84046645 程序员java开发语言
    publicvoidsend(Stringtext){channel.writeAndFlush(Unpooled.copiedBuffer(text.getBytes()));}publicvoidcloseConnect(){send(“bye”);channel.close();}}classMyHandlerextendsChannelInboundHandlerAdapter{@Over
  • 小孩应该给老人带还是自己带？ 是美芽啊
    我和老公住在县城里的房子，婆婆和公公在村子里种大棚蔬菜，住的是用石棉瓦搭的简易房子，虽然什么也不差，但出门就是泥土和大棚，不像我们在城里面小区下面有儿童乐园、健身设施，还有好多小朋友都会在那里玩。前几天宝宝刚满一岁，就送去菜地里断奶了，我也想自己出去工作贴补家用，以后宝宝就由婆婆和公公帮忙带，但是又放心不下宝宝，所以不知道该怎么选择？闺蜜告诉我：女人一定要有自己的事业和赚钱的能力，不能一味的在家里
  • Android 用线程池实现一个简单的任务队列(Kotlin) 深海呐 Android#Android进阶#Kotlinandroidkotlin线程池延时任务队列线程池延时任务
    关于线程池,Kotlin和java的使用方式一样在Android中,很多人喜欢用Handler的postDelayed()去实现延时任务.要使用postDelayed(),去实现延时任务队列,就不可避免要使用递归.但是这样做,代码的简洁性,和书写的简易,就远不如使用线程池.使用线程池的简单程度:privatevalmThreadPool=Executors.newSingleThreadSched
  • 自己实现一个简易RPC调用框架 殷俊杰
    最近在看dubbo，去创始人之一梁飞大神的博客搂了几眼，找到这个demo自己实现了一下，关于dubbo就不再介绍了，快速开始、框架设计、设计原则官网都有，有兴趣可以自己看Dubbo官网1.服务接口packagecom.yjj.my.api;/***@Description:*@Author:yinjunjie*@CreateDate:2018/8/713:16*@Version:1.0*/publ
  • 小程序——模板语法 无敌CV工程师 小程序小程序apache微信小程序前端
    文章目录声明和绑定数据声明和修改数据修改对象类型数据修改数组类型数据数据绑定-简易双向绑定列表渲染-基本使用列表渲染-使用进阶条件渲染声明和绑定数据小程序页面中使用的数据均需要在Page()方法的data对象中进行声明定义在将数据声明好以后，需要在WXML中绑定数据，数据绑定最简单的方式是使用Mustache语法（双大括号）将变量包起来。在{{}}内部可以做一些简单的运算，支持如下几种方式：算数运
  • Python世界：简易地址簿增删查改算法实践 来知晓 Python世界python机器学习开发语言
    Python世界：简易地址簿增删查改算法实践任务背景编码思路代码实现本文小结任务背景该任务来自简明Python教程中迈出下一步一章的问题：编写一款你自己的命令行地址簿程序，你可以用它浏览、添加、编辑、删除或搜索你的联系人，例如你的朋友、家人、同事，还有他们诸如邮件地址、电话号码等多种信息。这些详细信息必须被妥善储存以备稍后的检索。编码思路从问题中可以提炼以下信息：1、地址簿需要支持本地存储读写；2
  • webapck由浅入深——（Tapable） weixin_33737134 webpackViewUI
    webpack系列文章webpack由浅入深——（webpack基础配置）webpack由浅入深——（webpack优化配置）webpack由浅入深——（tapable）webpack由浅入深——（webapck简易版）webpack由浅入深——（ast、loader和plugin）Tapable和webpackTapable是基于发布订阅模式实现的一个类库，提供了许多Hook类，可创建许多钩子。
  • 烧粪 毛草台
    昨天下午到学校前的河边走走，刚下河堤，抬眼便见到小河对岸的西头远远的升起了袅袅的白烟。这是有人在烧粪。望着散漫升空的烟雾，久违的感觉突然浸透全身，生活在这个城市里，真是好久没有见到烧粪了。我三步并作两步，过简易桥到对岸，沿着新修的水泥路，朝西向胜蓝桥方向走去，很快就到了烧粪的地方，是胜蓝桥下不远处的河滩上。一中学校前的郁水河已列为风景观光带，两岸的土地早被征用。水泥路及河堤下的河滩处，原是岸上居民
  • Spring Data JPA kjcoder SpringDataJPA后端
    JPA概述JPA的全称是JavaPersistenceAPI，即Java持久化API，是SUN公司推出的一套基于ORM的规范，内部是由一系列的接口和抽象类构成。JPA规范不干活，真正干活的是依托与它的实现方式(例：hibernate)。搭建环境（需求：保存客户）1.创建maven工程导入坐标org.hibernatehibernate-entitymanager2.需要配置jpa的核心配置文件*位
  • Ubuntu搭建简易Postfix邮箱服务器 嫩草终结者 邮箱服务
    本文转载自https://www.linuxdashen.com/ubuntu%E6%90%AD%E5%BB%BA%E7%AE%80%E6%98%93postfix%E9%82%AE%E7%AE%B1%E6%9C%8D%E5%8A%A1%E5%99%A8Ubuntu搭建简易Postfix邮箱服务器最后更新2016年4月20日分类Ubuntu服务器最新文章邮件服务器标签550mailcontentd
  • Gerrit审核服务器搭建简易教程(Ubuntu 12.10) LKV_刘言
    //**********************************************欢迎转载，转载请注明出处，请尊重作者！http://blog.csdn.net/airk000Email:[email protected]//**********************************************本文将详细记录如何在一个全新的Ubuntu系统中安装及配置Gerri
  • 搭建第一个SpringDataJPA工程 码来码去（未来可期） JavaWebjava
    第一步：创建maven工程，导入maven坐标使用SpringDataJPA，需要整合Spring与SpringDataJPA，并且需要提供JPA的服务提供者hibernate，所以需要导入spring相关坐标，hibernate坐标，数据库驱动坐标等4.2.4.RELEASE5.0.7.Final1.6.61.2.120.9.1.25.1.6junitjunit4.9testorg.aspect
  • 讨论视频系统架构 Robin-LV MVCJDBC
    今天接到一个业务，领导让我搭建一个视频系统架构。架构采用MVC的模式这个大家都知道，技术采用Sping，hibernate3，数据层采用Sping提供的的jdbc模板。我知道要提供一些公共的的类和接口。还有一些封装好的方法。这个架构要考虑现在老系统的数据，等新系统完成要把数据导过去，还要考虑多平台融合的问题。由于我们公司有多套系统，领导想做底层统一以后好管理。现在晕晕的，请高手谈谈如何搭建一个好的
  • 简易版ts+axios封装 谷神神神 typescript
    用到了VITE变量，可以参考VITE变量使用方式importaxios,{AxiosRequestConfig}from"axios";constinstance=axios.create({baseURL:import.meta.env.VITE_DEVSERVER,});//在header中添加本地存储的token//其他操作同理instance.interceptors.request.us
  • log4jdbc使用介绍 leechiwi log4jdbc
    0前言使用java进行数据库操作时最痛苦的莫过于拼接SQL语句。在实际运行时往往需要查看实际生成的SQL语句和实际传入的参数，或许还会有查看SQL执行时间等的需求。无论原生JDBC、dbutils、mybatis还是hibernate，使用log4j等日志框架可以看到生成的SQL，但是占位符和参数总是分开打印的。实在是不太友好。显示如下的效果:select*fromt_userwhereage>?
  • 纯js简易五子棋 敬@过往 javascript前端开发语言
    一、利用canvas绘制五子棋（代码较为简陋请见谅）这里单独拿出一个绘制好的黑色五子棋展示五子棋-------------人生如棋，落子无悔！！！constcanvas=document.createElement('canvas');canvas.width=900;canvas.height=900;document.body.append(canvas);constcontext=canva
  • 使用爬虫写一个简易的翻译器+图像界面+python w²大大 python学习pythontkinterjson
    翻译器+图像界面+python1.效果图如下：2.代码实现1.效果图如下：2.代码实现importtkinterimportrandomimportrequestsimportrequestimporturllibfromurllibimportrequest,parseimporttime,json,random,hashlibwin=tkinter.Tk()defpachong():try:u
  • 水库 一片羽
    在我的老家的下游有一个大水库，是下游村庄的，不过源头在我们村，它似乎是两个村庄的分界线。小的时候每到夏天，为了防止下大雨淹了地，都会提前放水，每到放了水，我跟小伙伴就带上水桶、自制的简易捕鱼设备、渔网等，下到水库的浅滩上，捡河蚌螺丝，在细水下游的沟壑里放上自制的简易兜网，然后拿着铁丝绑制的棍子，我们叫做锤鱼神器，纵使鱼儿在水里游得飞快，但也难逃铁棍的锤击，即使逃过了铁棍，但也无法逃脱下游的兜网，每
  • 短视频矩阵源码 fendou--yx898978 抖音账号矩阵系统源码开发python开发语言矩阵
    矩阵系统源码主要有三种框架：Spring、Struts和Hibernate。Spring框架是一个全栈式的Java应用程序开发框架，提供了IOC容器、AOP、事务管理等功能。Struts框架是一个MVC架构的Web应用程序框架，用于将数据模型、Web应用程序的用户界面和控制器逻辑分离。Hibernate框架是一个面向对象的数据库访问框架，提供了ORM（对象关系映射）机制，允许开发人员使用面向对象的
  • Java项目中参数校验方法 DebugDiver代码深处潜水员 项目相关javapython开发语言
    Java项目中参数校验方法1.参数校验的重要性2.常见的参数校验方法2.1使用`assert`关键字2.2使用`Objects.requireNonNull`2.3使用自定义异常2.4使用`Preconditions`类2.5使用HibernateValidator注解2.6使用Spring框架内的验证2.7使用JSR303/349（BeanValidation）2.8使用ApacheCommon
  • PySimpleGUI制作简易停车场管理系统 DryHeyyy python开发语言
    此文章旨在记录自己学习内容，内容十分基础，还有许多不完善的多体谅：）停车场管理系统：若车辆到达，则显示汽车在停车场内或便道上的停车位置；若车辆离去，则显示汽车在停车场内停留的时间和应缴纳的费用，在便道停留不收费。1PySimpleGUI1.1简介PySimpleGUI是一个Python库，专为简化图形用户界面（GUI）的开发而设计。它提供了许多预定义的窗口和元素，可以使用PySimpleGUI来创
  • 2019-02-14 蒋聃浩
    《道德经》第六十三章[原文]为无为，事无事，味无味。大小多少。报怨以德。图难于其易，为大于其细；天下难事，必作于易；天下大事，必作于细。是以圣人终不为大，故能成其大。夫轻诺必寡信，多易必多难。是以圣人犹难之，故终无难矣。[译文]以无为的态度去有所作为，以不滋事的方法去处理事物，以恬淡无味当作有味。大生于小，多起于少。处理问题要从容易的地方入手，实现远大要从细微的地方入手。天下的难事，一定从简易的地
  • Java架构师学习路线 网络全息测量 心得体会
    (1)第一步：研究spring,hibernate。通过研究jeecms开源框架。也同时学习css,html,javascript,jquery.以前都学习过，不过没有系统学习过，现在必须系统学习。同时看cms相关的论文。然后，改造jeecms能够改为自己的一个开源框架，以后开发cms系统都用我自己开发的框架，作为第一阶段的成果。(2)第二步：学习开源工作流引擎Activiti5，jbpm4.4以
  • 基于UDP的简易网络聊天室 老K殿下 每日练习udp网络协议网络
    聊天室基本功能：1：群发的上下线通知2：服务器显示全部聊天信息，并且可以群发系统消息3：输入Q下线架构：客户端分为两个线程，主线程用来发送信息，子线程用来接收信息。发送的信息包是一个字符数组，包括1byte标识符、10byte用户昵称、128byte消息内容。它和记录ip地址和端口号的结构体共同组成一个结构体变量：structusrmsg。服务器也分为两个线程，主线程用来群发消息，子线程根据接收到
  • SpringBoot操作GBase8s数据库示例 迷你世界～爱丽丝
    SpringBoot+Hibernate(Jpa)操作GBase8s数据库示例GBase8s数据库是国产事务型数据库，目前已在各领域广泛应用，本篇使用当下主流的J2EE框架Springboot集成Hibernate（Jpa），对GBasse8S数据库CRUD操作进行讲解。1.技术点JPA是JAVA标准持久化API，是SUN公司推出的一套基于ORM的规范；Hibernate是对JPA（ORM规范）的
  • 微信小程序简易弹幕组件(uniapp) Vivqst 微信小程序uni-appjavascript
    最终效果图如下：1.弹幕从弹幕区域外的右边滚动到左边，那么每条弹幕的实际滚动路径长度为当前弹幕的实际宽度+整个弹幕区域的宽度组件代码如下：{{item.text}}{{currentBullet}}2.本例中弹幕区域的宽度为当前屏幕的宽度。弹幕的滚动效果使用css3的animation实现，使用translateX来实现水平位移的变化。弹幕使用绝对定位初始时在屏幕的最左边（left:0），动画开始
  • TOMCAT在POST方法提交参数丢失问题 357029540 javatomcatjsp
    摘自http://my.oschina.net/luckyi/blog/213209 昨天在解决一个BUG时发现一个奇怪的问题，一个AJAX提交数据在之前都是木有问题的，突然提交出错影响其他处理流程。 检查时发现页面处理数据较多，起初以为是提交顺序不正确修改后发现不是由此问题引起。于是删除掉一部分数据进行提交，较少数据能够提交成功。 恢复较多数据后跟踪提交FORM DATA ，发现数
  • 在MyEclipse中增加JSP模板 删除-2008-08-18 ljy325 jspxmlMyEclipse
    在D:\Program Files\MyEclipse 6.0\myeclipse\eclipse\plugins\com.genuitec.eclipse.wizards_6.0.1.zmyeclipse601200710\templates\jsp  目录下找到Jsp.vtl，复制一份，重命名为jsp2.vtl,然后把里面的内容修改为自己想要的格式，保存。 然后在 D:\Progr
  • JavaScript常用验证脚本总结 eksliang JavaScriptjavaScript表单验证
         转载请出自出处：http://eksliang.iteye.com/blog/2098985        下面这些验证脚本，是我在这几年开发中的总结，今天把他放出来，也算是一种分享吧，现在在我的项目中也在用！包括日期验证、比较，非空验证、身份证验证、数值验证、Email验证、电话验证等等...! &nb
  • 微软BI（4） 18289753290 微软BI SSIS
    1） Q:查看ssis里面某个控件输出的结果：  A MessageBox.Show(Dts.Variables["v_lastTimestamp"].Value.ToString()); 这是我们在包里面定义的变量 2):在关联目的端表的时候如果是一对多的关系，一定要选择唯一的那个键作为关联字段。 3) Q：ssis里面如果将多个数据源的数据插入目的端一
  • 定时对大数据量的表进行分表对数据备份 酷的飞上天空 大数据量
    工作中遇到数据库中一个表的数据量比较大，属于日志表。正常情况下是不会有查询操作的，但如果不进行分表数据太多，执行一条简单sql语句要等好几分钟。。   分表工具：linux的shell + mysql自身提供的管理命令 原理：使用一个和原表数据结构一样的表，替换原表。   linux shell内容如下： =======================开始 
  • 本质的描述与因材施教 永夜-极光 感想随笔
             不管碰到什么事,我都下意识的想去探索本质,找寻一个最形象的描述方式。        我坚信,世界上对一件事物的描述和解释,肯定有一种最形象,最贴近本质,最容易让人理解        &
  • 很迷茫。。。 随便小屋 随笔
    小弟我今年研一，也是从事的咱们现在最流行的专业（计算机）。本科三流学校，为了能有个更好的跳板，进入了考研大军，非常有幸能进入研究生的行业（具体学校就不说了，怕把学校的名誉给损了）。   先说一下自身的条件，本科专业软件工程。主要学习就是软件开发，几乎和计算机没有什么区别。因为学校本身三流，也就是让老师带着学生学点东西，然后让学生毕业就行了。对专业性的东西了解的非常浅。就那学的语言来说
  • 23种设计模式的意图和适用范围 aijuans 设计模式
    Factory Method 意图 定义一个用于创建对象的接口，让子类决定实例化哪一个类。Factory Method 使一个类的实例化延迟到其子类。 　　适用性 当一个类不知道它所必须创建的对象的类的时候。 　　当一个类希望由它的子类来指定它所创建的对象的时候。 　　当类将创建对象的职责委托给多个帮助子类中的某一个，并且你希望将哪一个帮助子类是代理者这一信息局部化的时候。 Abstr
  • Java中的synchronized和volatile aoyouzi javavolatilesynchronized
    说到Java的线程同步问题肯定要说到两个关键字synchronized和volatile。说到这两个关键字，又要说道JVM的内存模型。JVM里内存分为main memory和working memory。 Main memory是所有线程共享的，working memory则是线程的工作内存，它保存有部分main memory变量的拷贝，对这些变量的更新直接发生在working memo
  • js数组的操作和this关键字 百合不是茶 js数组操作this关键字
    js数组的操作;   一:数组的创建: 1、数组的创建 var array = new Array();　//创建一个数组 var array = new Array([size]);　//创建一个数组并指定长度，注意不是上限，是长度 var arrayObj = new Array([element0[, element1[, ...[, elementN]]]
  • 别人的阿里面试感悟 bijian1013 面试分享工作感悟阿里面试
    原文如下：http://greemranqq.iteye.com/blog/2007170         一直做企业系统，虽然也自己一直学习技术，但是感觉还是有所欠缺，准备花几个月的时间，把互联网的东西，以及一些基础更加的深入透析，结果这次比较意外，有点突然，下面分享一下感受吧！    &nb
  • 淘宝的测试框架Itest Bill_chen springmaven框架单元测试JUnit
    Itest测试框架是TaoBao测试部门开发的一套单元测试框架，以Junit4为核心， 集合DbUnit、Unitils等主流测试框架，应该算是比较好用的了。 近期项目中用了下，有关itest的具体使用如下： 1.在Maven中引入itest框架： <dependency>   <groupId>com.taobao.test</groupId&g
  • 【Java多线程二】多路条件解决生产者消费者问题 bit1129 java多线程
    package com.tom; import java.util.LinkedList; import java.util.Queue; import java.util.concurrent.ThreadLocalRandom; import java.util.concurrent.locks.Condition; import java.util.concurrent.loc
  • 汉字转拼音pinyin4j 白糖_ pinyin4j
    以前在项目中遇到汉字转拼音的情况，于是在网上找到了pinyin4j这个工具包，非常有用，别的不说了，直接下代码：   import java.util.HashSet; import java.util.Set; import net.sourceforge.pinyin4j.PinyinHelper; import net.sourceforge.pinyin
  • org.hibernate.TransactionException: JDBC begin failed解决方案 bozch ssh数据库异常DBCP
    org.hibernate.TransactionException: JDBC begin failed:     at org.hibernate.transaction.JDBCTransaction.begin(JDBCTransaction.java:68)    at org.hibernate.impl.SessionImp
  • java-并查集（Disjoint-set）-将多个集合合并成没有交集的集合 bylijinnan java
    import java.util.ArrayList; import java.util.Arrays; import java.util.HashMap; import java.util.HashSet; import java.util.Iterator; import java.util.List; import java.util.Map; import java.ut
  • Java PrintWriter打印乱码 chenbowen00 java
    一个小程序读写文件，发现PrintWriter输出后文件存在乱码，解决办法主要统一输入输出流编码格式。 读文件： BufferedReader 从字符输入流中读取文本，缓冲各个字符，从而提供字符、数组和行的高效读取。 可以指定缓冲区的大小，或者可使用默认的大小。大多数情况下，默认值就足够大了。 通常，Reader 所作的每个读取请求都会导致对基础字符或字节流进行相应的读取请求。因
  • [天气与气候]极端气候环境 comsci 环境
          如果空间环境出现异变...外星文明并未出现,而只是用某种气象武器对地球的气候系统进行攻击,并挑唆地球国家间的战争,经过一段时间的准备...最大限度的削弱地球文明的整体力量,然后再进行入侵......      那么地球上的国家应该做什么样的防备工作呢?  &n
  • oracle order by与union一起使用的用法 daizj UNIONoracleorder by
    当使用union操作时，排序语句必须放在最后面才正确，如下： 只能在union的最后一个子查询中使用order by，而这个order by是针对整个unioning后的结果集的。So： 如果unoin的几个子查询列名不同，如 Sql代码  select supplier_id, supplier_name  from suppliers  UNI
  • zeus持久层读写分离单元测试 deng520159 单元测试
    本文是zeus读写分离单元测试,距离分库分表,只有一步了.上代码: 1.ZeusMasterSlaveTest.java package com.dengliang.zeus.webdemo.test; import java.util.ArrayList; import java.util.List; import org.junit.Assert; import org.j
  • Yii 截取字符串(UTF-8) 使用组件 dcj3sjt126com yii
    1.将Helper.php放进protected\components文件夹下。 2.调用方法：   Helper::truncate_utf8_string($content,20,false);   //不显示省略号  Helper::truncate_utf8_string($content,20);  //显示省略号  &n
  • 安装memcache及php扩展 dcj3sjt126com PHP
    安装memcache    tar zxvf memcache-2.2.5.tgz     cd memcache-2.2.5/     /usr/local/php/bin/phpize (?)    ./configure --with-php-confi
  • JsonObject 处理日期 feifeilinlin521 javajsonJsonOjbectJsonArrayJSONException
        写这边文章的初衷就是遇到了json在转换日期格式出现了异常 net.sf.json.JSONException: java.lang.reflect.InvocationTargetException  原因是当你用Map接收数据库返回了java.sql.Date 日期的数据进行json转换出的问题话不多说  直接上代码  &n
  • Ehcache（06）——监听器 234390216 监听器listenerehcache
    监听器          Ehcache中监听器有两种，监听CacheManager的CacheManagerEventListener和监听Cache的CacheEventListener。在Ehcache中，Listener是通过对应的监听器工厂来生产和发生作用的。下面我们将来介绍一下这两种类型的监听器。  
  • activiti 自带设计器中chrome 34版本不能打开bug的解决 jackyrong Activiti
      在acitivti modeler中，如果是chrome 34，则不能打开该设计器，其他浏览器可以， 经证实为bug，参考 http://forums.activiti.org/content/activiti-modeler-doesnt-work-chrome-v34 修改为，找到 oryx.debug.js 在最头部增加 if (!Document.
  • 微信收货地址共享接口-终极解决 laotu5i0 微信开发
       最近要接入微信的收货地址共享接口，总是不成功，折腾了好几天，实在没办法网上搜到的帖子也是骂声一片。我把我碰到并解决问题的过程分享出来，希望能给微信的接口文档起到一个辅助作用，让后面进来的开发者能快速的接入，而不需要像我们一样苦逼的浪费好几天，甚至一周的青春。各种羞辱、谩骂的话就不说了，本人还算文明。    如果你能搜到本贴，说明你已经碰到了各种 ed
  • 关于人才 netkiller.github.com 工作面试招聘netkiller人才
    关于人才 每个月我都会接到许多猎头的电话，有些猎头比较专业，但绝大多数在我看来与猎头二字还是有很大差距的。 与猎头接触多了，自然也了解了他们的工作，包括操作手法，总体上国内的猎头行业还处在初级阶段。 总结就是“盲目推荐，以量取胜”。 目前现状 许多从事人力资源工作的人，根本不懂得怎么找人才。处在人才找不到企业，企业找不到人才的尴尬处境。 企业招聘，通常是需要用人的部门提出招聘条件，由人
  • 搭建 CentOS 6 服务器 - 目录 rensanning centos
    (1) 安装CentOS ISO（desktop/minimal）、Cloud（AWS/阿里云）、Virtualization（VMWare、VirtualBox） 详细内容 (2) Linux常用命令 cd、ls、rm、chmod...... 详细内容 (3) 初始环境设置 用户管理、网络设置、安全设置...... 详细内容 (4) 常驻服务Daemon
  • 【求助】mongoDB无法更新主键 toknowme mongodb
      Query query = new Query();          query.addCriteria(new Criteria("_id").is(o.getId()));                &n
  • jquery 页面滚动到底部自动加载插件集合 xp9802 jquery
    很多社交网站都使用无限滚动的翻页技术来提高用户体验，当你页面滑到列表底部时候无需点击就自动加载更多的内容。下面为你推荐 10 个 jQuery 的无限滚动的插件： 1. jQuery ScrollPagination jQuery ScrollPagination plugin 是一个 jQuery 实现的支持无限滚动加载数据的插件。 2. jQuery Screw S
按字母分类： ABCDEFGHIJKLMNOPQRSTUVWXYZ其他