在JavaEE中使用Hibernate框架

我们必须要了解一些Hibernate基础对象，如下：

配置对象

配置对象是你在任何 Hibernate 应用程序中创造的第一个 Hibernate 对象，并且经常只在应用程序初始化期间创造。它代表了 Hibernate 所需一个配置或属性文件。配置对象提供了两种基础组件。

  • 数据库连接：由 Hibernate 支持的一个或多个配置文件处理。这些文件是 hibernate.properties 和 hibernate.cfg.xml。
  • 类映射设置：这个组件创造了 Java 类和数据库表格之间的联系。

SessionFactory 对象

配置对象被用于创造一个 SessionFactory 对象，使用提供的配置文件为应用程序依次配置 Hibernate，并允许实例化一个会话对象。SessionFactory 是一个线程安全对象并由应用程序所有的线程所使用。SessionFactory 是一个重量级对象所以通常它都是在应用程序启动时创造然后留存为以后使用。每个数据库需要一个 SessionFactory 对象使用一个单独的配置文件。所以如果你使用多种数据库那么你要创造多种 SessionFactory 对象。

Session 对象

一个会话被用于与数据库的物理连接。Session 对象是轻量级的，并被设计为每次实例化都需要与数据库的交互。持久对象通过 Session 对象保存和检索。Session 对象不应该长时间保持开启状态因为它们通常情况下并非线程安全，并且它们应该按照所需创造和销毁。

Transaction 对象

一个事务代表了与数据库工作的一个单元并且大部分 RDBMS 支持事务功能。在 Hibernate 中事务由底层事务管理器和事务（来自 JDBC 或者 JTA）处理。这是一个选择性对象，Hibernate 应用程序可能不选择使用这个接口，而是在自己应用程序代码中管理事务。

Query 对象

Query 对象使用 SQL 或者 Hibernate 查询语言（HQL）字符串在数据库中来检索数据并创造对象。一个查询的实例被用于连结查询参数，限制由查询返回的结果数量，并最终执行查询。

Criteria 对象

Criteria 对象被用于创造和执行面向规则查询的对象来检索对象。

调用一个java方法需要正确的传递方法参数，那么使用框架就是引用别人封装好的jar包，按照别人规定好的方式进行配置并调用jar包里的各种方法。只要是合格的Java程序员都会引用jar包，只是不知道Hibernate官方提供的jar包哪些是必须引用的，哪些是扩展的。Hibernate官方提供了对jar包的说明，这里不再赘述。关键是怎样写好官方规定的配置文件，这是使用框架的重点

下面展示怎样使用Hibernate框架，关键是配置文件

（重点一：）Hibernate 需要事先知道在哪里找到映射信息，这些映射信息定义了 Java 类怎样关联到数据库表。（重点二：）Hibernate 也需要一套相关数据库和其它相关参数的配置设置。所有这些信息通常是作为一个标准的 Java 属性文件提供的，名叫 hibernate.properties。又或者是作为 XML 文件提供的，名叫 hibernate.cfg.xml。

我们将考虑 hibernate.cfg.xml 这个 XML 格式文件，来决定在我的例子里指定需要的 Hibernate 应用属性。这个 XML 文件中大多数的属性是不需要修改的。这个文件保存在应用程序的类路径的根目录里。

下面逐个贴出项目中各个文件的内容供大家参考

普通的pojo，没啥好说的

public class Employee {
       private int id;
       private String firstName;
       private String lastName;
       private int salary;  

       public Employee() {}
       public Employee(int id,String fname, String lname, int salary) {
          this.id = id;
          this.firstName = fname;
          this.lastName = lname;
          this.salary = salary;
       }
       public int getId() {
          return id;
       }
       //省略getter、setter方法
}

Employee类

（重点一：）数据库表和对象之间的映射关系

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

<hibernate-mapping>
   <class name="com.wenji.entity.Employee" table="HTCPP.EMPLOYEE">
      <meta attribute="class-description">
         This class contains the employee detail.
      </meta>
      <id name="id" type="int" column="id">
      </id>
      <property name="firstName" column="first_name" type="string"/>
      <property name="lastName" column="last_name" type="string"/>
      <property name="salary" column="salary" type="int"/>
   </class>
</hibernate-mapping>

映射文件

一个对象/关系型映射一般定义在 XML 文件中。映射文件指示 Hibernate 如何将已经定义的类或类组与数据库中的表对应起来。

尽管有些 Hibernate 用户选择手写 XML 文件，但是有很多工具可以用来给先进的 Hibernate 用户生成映射文件。这样的工具包括 XDoclet, Middlegen 和 AndroMDA。

让我们来考虑我们之前定义的 POJO 类，它的对象将延续到下一部分定义的表中。

create table EMPLOYEE(

ID INTEGER not null,
FIRST_NAME VARCHAR2(10),
LAST_NAME VARCHAR2(10),
SALARY INTEGER

)

你需要以格式 <classname>.hbm.xml保存映射文件。我们保存映射文件在 Employee.hbm.xml 中。让我们来详细地看一下在映射文件中使用的一些标签:

  • 映射文件是一个以 <hibernate-mapping> 为根元素的 XML 文件，里面包含所有<class>标签。
  • <class> 标签是用来定义从一个 Java 类到数据库表的特定映射。Java 的类名使用 name 属性来表示，数据库表明用 table 属性来表示。
  • <meta> 标签是一个可选元素，可以被用来修饰类。
  • <id> 标签将类中独一无二的 ID 属性与数据库表中的主键关联起来。id 元素中的 name 属性引用类的性质，column 属性引用数据库表的列。type 属性保存 Hibernate 映射的类型，这个类型会将从 Java 转换成 SQL 数据类型。
  • 在 id 元素中的 <generator> 标签用来自动生成主键值。设置 generator 标签中的 class 属性可以设置 native 使 Hibernate 可以使用 identity, sequence 或 hilo 算法根据底层数据库的情况来创建主键。
  • <property> 标签用来将 Java 类的属性与数据库表的列匹配。标签中 name 属性引用的是类的性质，column 属性引用的是数据库表的列。type 属性保存 Hibernate 映射的类型，这个类型会将从 Java 转换成 SQL 数据类型。

还有一些其它属性和元素可用在映射文件中。

（重点二：）数据库各项参数配置

<?xml version="1.0" encoding="utf-8"?>
<!DOCTYPE hibernate-configuration SYSTEM
"http://www.hibernate.org/dtd/hibernate-configuration-3.0.dtd">

<hibernate-configuration>
   <session-factory>
   <property name="hibernate.dialect">org.hibernate.dialect.Oracle9Dialect</property>
   <property name="hibernate.connection.driver_class">oracle.jdbc.driver.OracleDriver</property>

   <!-- Assume test is the database name -->
   <property name="hibernate.connection.url"> jdbc:oracle:thin:@localhost:1521:orcl</property>
   <property name="hibernate.connection.username">system</property>
   <property name="connection.password">123456</property>
   <property name="show_sql">true</property> 

   <!-- List of XML mapping files -->
   <mapping resource="com/wenji/mapping/Employee.hbm.xml"/>

</session-factory>
</hibernate-configuration>

hibernate.dialect：这个属性使 Hibernate 应用为被选择的数据库生成适当的 SQL。
hibernate.connection.driver_class：JDBC 驱动程序类。
hibernate.connection.url：数据库实例的 JDBC URL。
hibernate.connection.username：数据库用户名。
hibernate.connection.password：数据库密码。
hibernate.connection.pool_size：限制在 Hibernate 应用数据库连接池中连接的数量。
hibernate.connection.autocommit：允许在 JDBC 连接中使用自动提交模式。

调用jar包封装的方法

package com.wenji.test;

import java.util.List;
import java.util.Date;
import java.util.Iterator; 

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

import com.wenji.entity.Employee;

public class ManageEmployee {
    private static SessionFactory factory;
       public static void main(String[] args) {
          try{
             // 调用Configuration类的buildSessionFactory()方法：
             factory = new Configuration().configure().buildSessionFactory();
          }catch (Throwable ex) {
             System.err.println("Failed to create sessionFactory object." + ex);
             throw new ExceptionInInitializerError(ex);
          }
          ManageEmployee ME = new ManageEmployee();

          /* Add few employee records in database */
//          Integer empID1 = ME.addEmployee(1,"Zara", "Ali", 1000);
//          Integer empID2 = ME.addEmployee(2,"Daisy", "Das", 5000);
//          Integer empID3 = ME.addEmployee(3,"John", "Paul", 10000);

          /* List down all the employees */
          ME.listEmployees();

          /* Update employee‘s records */
//          ME.updateEmployee(empID1, 5000);

          /* Delete an employee from the database */
//          ME.deleteEmployee(empID2);

          /* List down new list of the employees */
//          ME.listEmployees();
       }
       /* Method to CREATE an employee in the database */
       public Integer addEmployee(int id,String fname, String lname, int salary){
          Session session = factory.openSession();
          Transaction tx = null;
          Integer employeeID = null;
          try{
             tx = session.beginTransaction();
             Employee employee = new Employee(id,fname, lname, salary);
             employeeID = (Integer) session.save(employee);
             tx.commit();
          }catch (HibernateException e) {
             if (tx!=null) tx.rollback();
             e.printStackTrace();
          }finally {
             session.close();
          }
          return employeeID;
       }
       /* Method to  READ all the employees */
       public void listEmployees( ){
          Session session = factory.openSession();
          Transaction tx = null;
          try{
             tx = session.beginTransaction();
             List employees = session.createQuery("FROM Employee").list();
             for (Iterator iterator =
                               employees.iterator(); iterator.hasNext();){
                Employee employee = (Employee) iterator.next();
                System.out.print("First Name: " + employee.getFirstName());
                System.out.print("  Last Name: " + employee.getLastName());
                System.out.println("  Salary: " + employee.getSalary());
             }
             tx.commit();
          }catch (HibernateException e) {
             if (tx!=null) tx.rollback();
             e.printStackTrace();
          }finally {
             session.close();
          }
       }
       /* Method to UPDATE salary for an employee */
       public void updateEmployee(Integer EmployeeID, int salary ){
          Session session = factory.openSession();
          Transaction tx = null;
          try{
             tx = session.beginTransaction();
             Employee employee =
                        (Employee)session.get(Employee.class, EmployeeID);
             employee.setSalary( salary );
             session.update(employee);
             tx.commit();
          }catch (HibernateException e) {
             if (tx!=null) tx.rollback();
             e.printStackTrace();
          }finally {
             session.close();
          }
       }
       /* Method to DELETE an employee from the records */
       public void deleteEmployee(Integer EmployeeID){
          Session session = factory.openSession();
          Transaction tx = null;
          try{
             tx = session.beginTransaction();
             Employee employee =
                       (Employee)session.get(Employee.class, EmployeeID);
             session.delete(employee);
             tx.commit();
          }catch (HibernateException e) {
             if (tx!=null) tx.rollback();
             e.printStackTrace();
          }finally {
             session.close();
          }
       }
}

测试方法

会话

Session 用于获取与数据库的物理连接。 Session 对象是轻量级的，并且设计为在每次需要与数据库进行交互时被实例化。持久态对象被保存，并通过 Session 对象检索找回。

该 Session 对象不应该长时间保持开放状态，因为它们通常不能保证线程安全，而应该根据需求被创建和销毁。Session 的主要功能是为映射实体类的实例提供创建，读取和删除操作。这些实例可能在给定时间点时存在于以下三种状态之一：

  • 瞬时状态: 一种新的持久性实例，被 Hibernate 认为是瞬时的，它不与 Session 相关联，在数据库中没有与之关联的记录且无标识符值。
  • 持久状态：可以将一个瞬时状态实例通过与一个 Session 关联的方式将其转化为持久状态实例。持久状态实例在数据库中没有与之关联的记录，有标识符值，并与一个 Session 关联。
  • 脱管状态：一旦关闭 Hibernate Session，持久状态实例将会成为脱管状态实例。

若 Session 实例的持久态类别是序列化的，则该 Session 实例是序列化的。一个典型的事务应该使用以下语法：

Session session = factory.openSession();
Transaction tx = null;
try {
   tx = session.beginTransaction();
   // do some work
   ...
   tx.commit();
}
catch (Exception e) {
   if (tx!=null) tx.rollback();
   e.printStackTrace();
}finally {
   session.close();
}

如果 Session 引发异常，则事务必须被回滚，该 session 必须被丢弃。

Session 接口提供了很多方法，但在示例中仅展示几个重要方法。可以查看 Hibernate 文件，查询与 Session 及 SessionFactory 相关的完整方法目录

到现在为止，你已经看到 Hibernate 如何使用 XML 映射文件来完成从 POJO 到数据库表的数据转换的，反之亦然。Hibernate 注释是无需使用 XML 文件来定义映射的最新方法。你可以额外使用注释或直接代替 XML 映射元数据。

Hibernate 注释是一种强大的来给对象和关系映射表提供元数据的方法。所有的元数据被添加到 POJO java 文件代码中，这有利于用户在开发时更好的理解表的结构和 POJO。

如果你想让你的应用程序移植到其它 EJB 3 的 ORM 应用程序中,您必须使用注释来表示映射信息，但是如果想要得到更大的灵活性,那么你应该使用基于 XML 的映射。

Hibernate 注释的环境设置

首先你必须确定你使用的是 JDK 5.0，否则你需要升级你的 JDK 至 JDK 5.0，来使你的主机能够支持注释。

其次，你需要安装 Hibernate 注释包，可以从 sourceforge 行下载：（下载 Hibernate 注释） 并且从 Hibernate 注释发布中拷贝 hibernate-annotations.jar, lib/hibernate-comons-annotations.jar 和 lib/ejb3-persistence.jar 到你的 CLASSPATH。

项目结构如下，和之前的项目结构相比，少了Employee.hbm.xml，这个xml文件是用来描述数据库表与java对象的映射关系的，那么这个文件被谁替代了呢？

下面逐个贴出项目中各个文件的内容供大家参考

package com.wenji.entity;

import javax.persistence.*;

@Entity
@Table(name = "htcpp.EMPLOYEE")
public class Employee {
       @Id
       @Column(name = "id")
       private int id;

       @Column(name = "first_name")
       private String firstName;

       @Column(name = "last_name")
       private String lastName;

       @Column(name = "salary")
       private int salary;  

       public Employee() {}
       public Employee(int id,String fname, String lname, int salary) {
          this.id = id;
          this.firstName = fname;
          this.lastName = lname;
          this.salary = salary;
       }
       //省略getter、setter方法
}

@Entity 注释

EJB 3 标准的注释包含在 javax.persistence 包，所以我们第一步需要导入这个包。第二步我们对 Employee 类使用 @Entity 注释，标志着这个类为一个实体 bean，所以它必须含有一个没有参数的构造函数并且在可保护范围是可见的。

@Table 注释

@table 注释允许您明确表的详细信息保证实体在数据库中持续存在。

@table 注释提供了四个属性，允许您覆盖的表的名称，目录及其模式,在表中可以对列制定独特的约束。现在我们使用的是表名为 EMPLOYEE。

@Id 和 @GeneratedValue 注释

每一个实体 bean 都有一个主键，你在类中可以用 @Id 来进行注释。主键可以是一个字段或者是多个字段的组合，这取决于你的表的结构。

默认情况下，@Id 注释将自动确定最合适的主键生成策略，但是你可以通过使用 @GeneratedValue 注释来覆盖掉它。strategy 和 generator 这两个参数我不打算在这里讨论，所以我们只使用默认键生成策略。让 Hibernate 确定使用哪些生成器类型来使代码移植于不同的数据库之间。

@Column Annotation

@Column 注释用于指定某一列与某一个字段或是属性映射的细节信息。您可以使用下列注释的最常用的属性:

  • name 属性允许显式地指定列的名称。
  • length 属性为用于映射一个值，特别为一个字符串值的列的大小。
  • nullable 属性允许当生成模式时，一个列可以被标记为非空。
  • unique 属性允许列中只能含有唯一的内容

hibernate.cfg.xml文件和之前相比，注释掉了映射文件的信息

<?xml version="1.0" encoding="utf-8"?>
<!DOCTYPE hibernate-configuration SYSTEM
"http://www.hibernate.org/dtd/hibernate-configuration-3.0.dtd">

<hibernate-configuration>
   <session-factory>
   <property name="hibernate.dialect">org.hibernate.dialect.Oracle9Dialect</property>
   <property name="hibernate.connection.driver_class">oracle.jdbc.driver.OracleDriver</property>

   <!-- Assume test is the database name -->
   <property name="hibernate.connection.url"> jdbc:oracle:thin:@localhost:1521:orcl</property>
   <property name="hibernate.connection.username">system</property>
   <property name="connection.password">123456</property>
   <property name="show_sql">true</property> 

   <!-- List of XML mapping files -->
   <!--    <mapping resource="com/wenji/mapping/Employee.hbm.xml"/> -->

</session-factory>
</hibernate-configuration>

和之前的示例方法相比，只有创建factory的方式变了，其他的都一样

package com.wenji.test;

import java.util.List;
import java.util.Date;
import java.util.Iterator; 

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

import com.wenji.entity.Employee;

public class ManageEmployee {
   private static SessionFactory factory;
   public static void main(String[] args) {
      try{
         factory = new AnnotationConfiguration().
                   configure().
                   //addPackage("com.xyz") //add package if used.
                   addAnnotatedClass(Employee.class).
                   buildSessionFactory();
      }catch (Throwable ex) {
         System.err.println("Failed to create sessionFactory object." + ex);
         throw new ExceptionInInitializerError(ex);
      }
      ManageEmployee ME = new ManageEmployee();

      /* Add few employee records in database */
//      Integer empID1 = ME.addEmployee("Zara", "Ali", 1000);
//      Integer empID2 = ME.addEmployee("Daisy", "Das", 5000);
//      Integer empID3 = ME.addEmployee("John", "Paul", 10000);

      /* List down all the employees */
      ME.listEmployees();

      /* Update employee‘s records */
//      ME.updateEmployee(empID1, 5000);

      /* Delete an employee from the database */
//      ME.deleteEmployee(empID2);

      /* List down new list of the employees */
//      ME.listEmployees();
   }
   /* Method to CREATE an employee in the database */
   public Integer addEmployee(String fname, String lname, int salary){
      Session session = factory.openSession();
      Transaction tx = null;
      Integer employeeID = null;
      try{
         tx = session.beginTransaction();
         Employee employee = new Employee();
         employee.setFirstName(fname);
         employee.setLastName(lname);
         employee.setSalary(salary);
         employeeID = (Integer) session.save(employee);
         tx.commit();
      }catch (HibernateException e) {
         if (tx!=null) tx.rollback();
         e.printStackTrace();
      }finally {
         session.close();
      }
      return employeeID;
   }
   /* Method to  READ all the employees */
   public void listEmployees( ){
      Session session = factory.openSession();
      Transaction tx = null;
      try{
         tx = session.beginTransaction();
         List employees = session.createQuery("FROM Employee").list();
         for (Iterator iterator =
                           employees.iterator(); iterator.hasNext();){
            Employee employee = (Employee) iterator.next();
            System.out.print("First Name: " + employee.getFirstName());
            System.out.print("  Last Name: " + employee.getLastName());
            System.out.println("  Salary: " + employee.getSalary());
         }
         tx.commit();
      }catch (HibernateException e) {
         if (tx!=null) tx.rollback();
         e.printStackTrace();
      }finally {
         session.close();
      }
   }
   /* Method to UPDATE salary for an employee */
   public void updateEmployee(Integer EmployeeID, int salary ){
      Session session = factory.openSession();
      Transaction tx = null;
      try{
         tx = session.beginTransaction();
         Employee employee =
                    (Employee)session.get(Employee.class, EmployeeID);
         employee.setSalary( salary );
         session.update(employee);
         tx.commit();
      }catch (HibernateException e) {
         if (tx!=null) tx.rollback();
         e.printStackTrace();
      }finally {
         session.close();
      }
   }
   /* Method to DELETE an employee from the records */
   public void deleteEmployee(Integer EmployeeID){
      Session session = factory.openSession();
      Transaction tx = null;
      try{
         tx = session.beginTransaction();
         Employee employee =
                   (Employee)session.get(Employee.class, EmployeeID);
         session.delete(employee);
         tx.commit();
      }catch (HibernateException e) {
         if (tx!=null) tx.rollback();
         e.printStackTrace();
      }finally {
         session.close();
      }
   }
}

测试方法

原文地址：https://www.cnblogs.com/jwen1994/p/10243058.html

时间： 2024-10-31 18:24:53

在JavaEE中使用Hibernate框架的相关文章

浅谈JavaEE中的Hibernate环境的搭建(二)

从今天开始,我们一起来进入有关Hibernate框架的学习,Hibernate框架实际上是基于JDBC的高度封装的框架,所以对比起来Hibernate的运行效率没有JDBC效率高但是Hibernate的开发效率却比JDBC的要高,这也是企业级开发所追求的.所以目前大部分企业开发都不会使用JDBC.欲工善其事,必先利其器,首先我们熟悉下Hibernate环境搭建. Hibernate环境搭建步骤: 第一步:获取到Hibernate发布包,可以去Hibernate官网上去下载,或者去GitHub直接

javaEE中的hibernate配置笔记

0 从web.xml出发 项目中用Spring整合Hibernate,Spring贯穿整个项目,所以先看看Spring在哪一步整合了Hibernate.先看部分web.xml. 在context-param设定参数contextConfigLocation. 在listener配置基于Web上下文级别的监听器ContextLoaderListener,它会加载contextConfigLocation中的配置文件. 其中最重要的是spring-hibernate.xml,这里面配置了hibern

浅谈JavaEE中的Hibernate中的四种关系映射(三)

今天我们一起来探讨一下有关Hibernate四种关系映射,大家可能会有疑惑,关系映射不就是只有三种(一对一,一对多,多对多)吗?这里我们再多说一个继承映射关系,虽然它使用频繁度没有前三个那么多,但是它在一些特定情况下,还是非常有用的,至于有什么用下面马上就要讲.这些关系映射实际上就是对应着关系型数据库中的几种关系的类型.我们都知道Hibernate的作用是将面向关系数据操作,转换成面向对象的操作,其中关系映射文件就是实现这个转换的核心.我们都知道如果我们仅仅使用SQL语句建表并且去维护表与表之间

在JavaEE中使用Mybatis框架

MyBatis 使用简单的 XML 或注解用于配置和原始映射,将接口和 Java 的 POJOs(Plain Old Java Objects,普通的 Java 对象)映射成数据库中的记录.每个MyBatis应用程序主要都是使用SqlSessionFactory实例的,一个SqlSessionFactory实例可以通过SqlSessionFactoryBuilder获得.SqlSessionFactoryBuilder可以从一个xml配置文件或者一个预定义的配置类的实例获得. 使用框架就是引用别

粗浅看Struts2和Hibernate框架

----------------------------------------------------------------------------------------------[版权申明:本文系作者原创,转载请注明出处] 文章出处:http://blog.csdn.net/sdksdk0/article/details/52424578作者:朱培      ID:sdksdk0      邮箱: [email protected] --------------------------

java：Hibernate框架（环境搭建，Hibernate.cfg.xml中属性含义，Hibernate常用API对象，HibernteUitl，对象生命周期图，数据对象的三种状态）

1.环境搭建: 三个准备+7个步骤 准备1:新建项目并添加hibernate依赖的jar文件  准备2:在classpath下(src目录下)新建hibernate的配置文件:hibernate.cfg.xml <?xml version="1.0" encoding="UTF-8"?> <!DOCTYPE hibernate-configuration PUBLIC "-//Hibernate/Hibernate Configurati

Hibernate框架中的HibernateUtil

对于刚学习三层框架的人来说,每一个配置文件和每一个类,以及功能来说都很新鲜,时常就忘记了相关类的功能. 在这里建议编程就是要多加练习,才能熟能生巧. 这里说一下HibernateUtil类,在使用Hibernate的前提是需要去下载Hibernate项目,然后在lib文件夹下面把所有的. jar 包 COPY到你项目的lib文件夹下. 什么是HibernateUtil类,或者是说有什么功能? Hibernate框架,主要解决的就是项目于数据库连接相关的问题,然而主要实现是需要靠配置文件中的代码与

在Eclipse中使用Struts和Hibernate框架搭建Maven Web项目

前言 学习使用Java还是2012年的事情,刚开始学习的Java的时候,使用的是MyEclipse工具和SSH框架.初学者适合使用MyEclipse,因为他将struts.Spring和Hibernate等框架集成在IDE中,可以直接通过添加Capacities将这些框架集成到Web Project中,相应的Jar包也会自动添加到lib目录下,开发过程中还是需要手动添加一些jar包.再后来开始接触Maven,在Eclipse下搭建Maven Web项目.在后来就转C#项目开发了,项目做了快两年的

SSH(Struts2+Spring+Hibernate)框架搭建流程&lt;注解的方式创建Bean&gt;

此篇讲的是MyEclipse9工具提供的支持搭建自加包有代码也是相同:用户登录与注册的例子,表字段只有name,password. SSH,xml方式搭建文章链接地址:http://www.cnblogs.com/wkrbky/p/5912810.html 一.Hibernate(数据层)的搭建: 实现流程 二.Spring(注入实例)的使用: 实现流程 三.Struts2(MVC)的搭建: 实现流程 这里注意一点问题: Struts2与Hibernate在一起搭建,antlr包,有冲突.MyE