Maven与Hibernate结合

最新推荐文章于 2025-06-18 10:17:27 发布
最新推荐文章于 2025-06-18 10:17:27 发布
阅读量2.6k 收藏 2
点赞数
CC 4.0 BY-SA版权
分类专栏： Maven hibernate 文章标签： Maven Hibernate web
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/ps_zhanglei/article/details/42098307
本文介绍了如何将Maven和Hibernate结合，通过在Maven项目中添加Hibernate依赖，配置hibernate.cfg.xml，创建Entity类和Mapping文件。接着，文章展示了如何进行测试，将项目转化为Web项目，并创建Servlet。通过在pom.xml中调整配置，执行mvn命令，最终实现了一个简单的Web项目集成。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

使用了maven之后我们可以将项目的构件与发布变得非常的简单。Maven与Hibernate也是可以结合在一起的。首先我们创建一个Maven的项目。在依赖中我们要加入Hibernate的依赖，pom文件可以这样写：

<?xml version="1.0"?>
<project xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd" xmlns="http://maven.apache.org/POM/4.0.0"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">
  <modelVersion>4.0.0</modelVersion>
  <groupId>org.hibernate.tutorials</groupId>
  <artifactId>hibernate-tutorial</artifactId>
  <version>1.0.0-SNAPSHOT</version>
  <name>First Hibernate Tutorial</name>
  <dependencies>
    <dependency>
      <groupId>antlr</groupId>
      <artifactId>antlr</artifactId>
      <version>2.7.7</version>
    </dependency>
    <dependency>
      <groupId>dom4j</groupId>
      <artifactId>dom4j</artifactId>
      <version>1.6.1</version>
    </dependency>
    <dependency>
      <groupId>org.hibernate.common</groupId>
      <artifactId>hibernate-commons-annotations</artifactId>
      <version>4.0.4.Final</version>
    </dependency>
    <dependency>
      <groupId>org.hibernate</groupId>
      <artifactId>hibernate-core</artifactId>
      <version>4.3.4.Final</version>
    </dependency>
    <dependency>
      <groupId>org.hibernate.javax.persistence</groupId>
      <artifactId>hibernate-jpa-2.0-api</artifactId>
      <version>1.0.1.Final</version>
    </dependency>
    <dependency>
      <groupId>org.jboss</groupId>
      <artifactId>jandex</artifactId>
      <version>1.2.2.Final</version>
    </dependency>
    <dependency>
      <groupId>org.javassist</groupId>
      <artifactId>javassist</artifactId>
      <version>3.18.2-GA</version>
    </dependency>
    <dependency>
      <groupId>org.hibernate</groupId>
      <artifactId>hibernate-entitymanager</artifactId>
      <version>4.3.4.Final</version>
    </dependency>
    <dependency>
      <groupId>javax.validation</groupId>
      <artifactId>validation-api</artifactId>
      <version>1.0.0.GA</version>
      <scope>provided</scope>
    </dependency>
    <dependency>
      <groupId>org.slf4j</groupId>
      <artifactId>slf4j-api</artifactId>
      <version>1.6.4</version>
    </dependency>
    <dependency>
      <groupId>org.jboss.logging</groupId>
      <artifactId>jboss-logging</artifactId>
      <version>3.1.0.CR2</version>
    </dependency>
    <dependency>
      <groupId>org.jboss.spec.javax.transaction</groupId>
      <artifactId>jboss-transaction-api_1.1_spec</artifactId>
      <version>1.0.1.Final</version>
    </dependency>
    <dependency>
      <groupId>org.jboss.logging</groupId>
      <artifactId>jboss-logging-annotations</artifactId>
      <version>1.2.0.Beta1</version>
    </dependency>
    <dependency>
      <groupId>org.slf4j</groupId>
      <artifactId>slf4j-log4j12</artifactId>
      <version>1.6.4</version>
    </dependency>
    <dependency>
      <groupId>junit</groupId>
      <artifactId>junit</artifactId>
      <version>4.12</version>
      <scope>test</scope>
    </dependency>
    <dependency>
      <groupId>log4j</groupId>
      <artifactId>log4j</artifactId>
      <version>1.2.12</version>
    </dependency>
    <dependency>
      <groupId>mysql</groupId>
      <artifactId>mysql-connector-java</artifactId>
      <version>5.1.34</version>
    </dependency>
    <dependency>
      <groupId>org.apache.openejb</groupId>
      <artifactId>javaee-api</artifactId>
      <version>6.0-6</version>
    </dependency>
    <dependency>
      <groupId>org.apache.openejb</groupId>
      <artifactId>javaee-api</artifactId>
      <version>5.0-1</version>
      <scope>provided</scope>
    </dependency>
    <dependency>
      <groupId>javax.servlet</groupId>
      <artifactId>jstl</artifactId>
      <version>1.2</version>
      <scope>provided</scope>
    </dependency>
    <dependency>
      <groupId>javax.servlet.jsp</groupId>
      <artifactId>jsp-api</artifactId>
      <version>2.1</version>
      <scope>provided</scope>
    </dependency>
  </dependencies>
</project>
同时要手工创建一些必须的包，建好之后的项目文件结构如下：

然后按照正常的Hibernate的编写顺序写配置文件，Entity类以及Mapping文件：

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>

    <session-factory>

         <property name="connection.driver_class">com.mysql.jdbc.Driver</property>
        <property name="connection.url">jdbc:mysql://localhost:3306/hibernate</property>
        <property name="connection.username">root</property>
        <property name="connection.password">root</property>
        <property name="dialect">org.hibernate.dialect.MySQLDialect</property>

        <!-- JDBC connection pool (use the built-in) -->
        <property name="connection.pool_size">1</property>

        <!-- Enable Hibernate's automatic session context management -->
        <property name="current_session_context_class">thread</property>

        <!-- Disable the second-level cache  -->
        <property name="cache.provider_class">org.hibernate.cache.NoCacheProvider</property>

        <!-- Echo all executed SQL to stdout -->
        <property name="show_sql">true</property>
        <property name="format_sql">true</property>

        <!-- Drop and re-create the database schema on startup -->
        <property name="hbm2ddl.auto">update</property>

        <mapping resource="Event.hbm.xml"/>
        <mapping resource="Person.hbm.xml"/>

    </session-factory>

</hibernate-configuration>
Event.java： 

package com.smile.pansoft.mavenhibernate.domains;

import java.util.Date;
import java.util.HashSet;
import java.util.Set;

public class Event {
    private int id;

    private String title;
    private Date date;
    
    private Set participants = new HashSet();
    

    public Event() {}

    public int getId() {
        return id;
    }

    private void setId(int id) {
        this.id = id;
    }

    public Date getDate() {
        return date;
    }

    public void setDate(Date date) {
        this.date = date;
    }

    public String getTitle() {
        return title;
    }

    public void setTitle(String title) {
        this.title = title;
    }
    
    public Set getParticipants() {
        return participants;
    }

    public void setParticipants(Set participants) {
        this.participants = participants;
    }
   
}
Event.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.smile.pansoft.mavenhibernate.domains">

    <class name="Event" table="EVENTS">
        <id name="id" column="EVENT_ID">
            <generator class="native"/>
        </id>
        <property name="date" type="timestamp" column="EVENT_DATE"/>
        <property name="title"/>
        <!-- inverse=“true” -->
        <set name="participants" table="PERSON_EVENT" inverse="true">
            <key column="EVENT_ID"/>
            <many-to-many column="PERSON_ID" class="Person"/>
        </set>
    </class>

</hibernate-mapping>

Person.java：

package com.smile.pansoft.mavenhibernate.domains;

import java.util.HashSet;
import java.util.Set;

public class Person {

	private int id;
	private int age;
	private String firstname;
	private String lastname;
	private Set events = new HashSet();
	private Set emailAddresses = new HashSet();

	public Person() {
	}

	public int getId() {
		return id;
	}

	public void setId(int id) {
		this.id = id;
	}

	public int getAge() {
		return age;
	}

	public void setAge(int age) {
		this.age = age;
	}

	public String getFirstname() {
		return firstname;
	}

	public void setFirstname(String firstname) {
		this.firstname = firstname;
	}

	public String getLastname() {
		return lastname;
	}

	public void setLastname(String lastname) {
		this.lastname = lastname;
	}

	public Set getEvents() {
		return events;
	}

	public void setEvents(Set events) {
		this.events = events;
	}

	public void addToEvent(Event event) {
		this.getEvents().add(event);
		event.getParticipants().add(this);
	}

	public void removeFromEvent(Event event) {
		this.getEvents().remove(event);
		event.getParticipants().remove(this);
	}

	public Set getEmailAddresses() {
		return emailAddresses;
	}

	public void setEmailAddresses(Set emailAddresses) {
		this.emailAddresses = emailAddresses;
	}

}
Person.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.smile.pansoft.mavenhibernate.domains">

    <class name="Person" table="PERSON">
        <id name="id" column="PERSON_ID">
            <generator class="native"/>
        </id>
        <property name="age"/>
        <property name="firstname"/>
        <property name="lastname"/>
        <set name="events" table="PERSON_EVENT">
        	<key column="PERSON_ID"/>
       		<many-to-many column="EVENT_ID" class="Event"/>
    	</set>
    	<set name="emailAddresses" table="PERSON_EMAIL_ADDR">
            <key column="PERSON_ID"/>
            <element type="string" column="EMAIL_ADDR"/>
        </set>
    </class>
</hibernate-mapping>
这里需要注意的是用到的是many-to-many的设置，其中还用到了一个element的设置。具体的数据库表结构为：

各个文件位置如下：

配置文件全都放到resources目录的下面，注意引用时的路径。

可以先建立测试类进行测试，注意测试类名字的命名规则，在之前的文章中已有介绍：

EventManagerTest.java：

package com.smile.pansoft.mavenhibernate.test;


import org.hibernate.Session;
import org.junit.Test;

import com.smile.pansoft.mavenhibernate.domains.Event;
import com.smile.pansoft.mavenhibernate.domains.Person;
import com.smile.pansoft.mavenhibernate.util.HibernateUtil;


public class EventManagerTest {

    public static void main(String[] args) {
        EventManagerTest mgr = new EventManagerTest();
//        mgr.createAndStoreEvent("My Event", new Date());
        HibernateUtil.getSessionFactory().close();
    }
    
    /*
    @Test
    public void createAndStoreEvent() {
    	System.out.println("start test");
        Session session = HibernateUtil.getSessionFactory().getCurrentSession();
        session.beginTransaction();

        Event theEvent = new Event();
        theEvent.setTitle("teacher");
        theEvent.setDate(new Date());
        session.save(theEvent);

        session.getTransaction().commit();
    }
    
    @Test
    public void listEvents() {
        Session session = HibernateUtil.getSessionFactory().getCurrentSession();
        session.beginTransaction();
        List result = session.createQuery("from Event").list();
        session.getTransaction().commit();
        for (int i = 0; i < result.size(); i++) {
            Event theEvent = (Event) result.get(i);
            System.out.println(
                    "Event: " + theEvent.getTitle() + " Time: " + theEvent.getDate()
            );
        }
    }
    */
    @Test
    public void addPersonToEvent() {
    	//第一種方式 直接操作list 這樣直接在persistent状态进行操作时，Hibernate会直接进行校验automatic dirty checking 直接持久化到数据库中
//        Session session = HibernateUtil.getSessionFactory().getCurrentSession();
//        session.beginTransaction();
//
//        Person aPerson = (Person) session.load(Person.class, 1);
//        Event anEvent = (Event) session.load(Event.class, 1);
//        aPerson.getEvents().add(anEvent);
//        System.out.println(aPerson.getFirstname());
//        Set stuSet = aPerson.getEvents();
//        System.out.println(stuSet.size());
//        session.getTransaction().commit();
    	 Session session = HibernateUtil.getSessionFactory().getCurrentSession();
         session.beginTransaction();

         //fetch的作用 Hibernate默认的load方式是lazy只会加载当前对象 而对于list不进行加载 而当我们设置lazy=false的时候 又会全部加载 所以使用fetch可以主动进行提取 进行热加载
         Person aPerson = (Person) session
                 .createQuery("select p from Person p left join fetch p.events where p.id = :pid")
                 .setParameter("pid", 2)
                 .uniqueResult(); // Eager fetch the collection so we can use it detached
         Event anEvent = (Event) session.load(Event.class, 2);

         session.getTransaction().commit();

         // End of first unit of work

         aPerson.getEvents().add(anEvent); // aPerson (and its collection) is detached

         // Begin second unit of work

         Session session2 = HibernateUtil.getSessionFactory().getCurrentSession();
         session2.beginTransaction();
         session2.update(aPerson); // Reattachment of aPerson

         session2.getTransaction().commit();
    }
	
    
    @Test
    public void addEmailToPerson() {
        Session session = HibernateUtil.getSessionFactory().getCurrentSession();
        session.beginTransaction();

        Person aPerson = (Person) session.load(Person.class, 1);
        // adding to the emailAddress collection might trigger a lazy load of the collection
        aPerson.getEmailAddresses().add("ga_smile_nk@sina.com");

        session.getTransaction().commit();
    }

}
HibernateUtil.java： 

package com.smile.pansoft.mavenhibernate.util;


import org.hibernate.SessionFactory;
import org.hibernate.boot.registry.StandardServiceRegistryBuilder;
import org.hibernate.cfg.Configuration;

public class HibernateUtil {

    private static final SessionFactory sessionFactory = buildSessionFactory();

    private static SessionFactory buildSessionFactory() {
    	try {
			// Create the SessionFactory from hibernate.cfg.xml
//			SessionFactory sc = new Configuration().configure().buildSessionFactory(
//					new StandardServiceRegistryBuilder().build());
			Configuration cfg = new Configuration().configure();
			SessionFactory sc = cfg.buildSessionFactory(new StandardServiceRegistryBuilder().applySettings(cfg.getProperties()).build());
			return sc;
		} catch (Throwable ex) {
			// Make sure you log the exception, as it might be swallowed
			System.err.println("Initial SessionFactory creation failed." + ex);
			throw new ExceptionInInitializerError(ex);
		}
    }

    public static SessionFactory getSessionFactory() {
        return sessionFactory;
    }

}
可以在IDE中直接执行测试类的方法。或者使用mvn的test命令进行执行，执行结果如下： 

-------------------------------------------------------
 T E S T S
-------------------------------------------------------
Running com.smile.pansoft.mavenhibernate.test.EventManagerTest
09:06:51,881  WARN org.hibernate.engine.jdbc.connections.internal.DriverManagerConnectionProviderImpl:93 - HHH000402: Using Hibernate built-in connection pool (not for production use!)
09:06:52,780  INFO org.hibernate.tool.hbm2ddl.SchemaUpdate:182 - HHH000228: Running hbm2ddl schema update
09:06:52,781  INFO org.hibernate.tool.hbm2ddl.SchemaUpdate:193 - HHH000102: Fetching database metadata
09:06:52,783  INFO org.hibernate.tool.hbm2ddl.SchemaUpdate:205 - HHH000396: Updating schema
09:06:52,808  INFO org.hibernate.tool.hbm2ddl.TableMetadata:66 - HHH000261: Table found: hibernate.events
09:06:52,809  INFO org.hibernate.tool.hbm2ddl.TableMetadata:67 - HHH000037: Columns: [title, event_date, event_id]
09:06:52,809  INFO org.hibernate.tool.hbm2ddl.TableMetadata:69 - HHH000108: Foreign keys: []
09:06:52,810  INFO org.hibernate.tool.hbm2ddl.TableMetadata:70 - HHH000126: Indexes: [primary]
09:06:52,819  INFO org.hibernate.tool.hbm2ddl.TableMetadata:66 - HHH000261: Table found: hibernate.person
09:06:52,820  INFO org.hibernate.tool.hbm2ddl.TableMetadata:67 - HHH000037: Columns: [person_id, age, lastname, firstname]
09:06:52,821  INFO org.hibernate.tool.hbm2ddl.TableMetadata:69 - HHH000108: Foreign keys: []
09:06:52,821  INFO org.hibernate.tool.hbm2ddl.TableMetadata:70 - HHH000126: Indexes: [primary]
09:06:52,832  INFO org.hibernate.tool.hbm2ddl.TableMetadata:66 - HHH000261: Table found: hibernate.person_email_addr
09:06:52,833  INFO org.hibernate.tool.hbm2ddl.TableMetadata:67 - HHH000037: Columns: [person_id, email_addr]
09:06:52,833  INFO org.hibernate.tool.hbm2ddl.TableMetadata:69 - HHH000108: Foreign keys: [fk_fipu5nseny7muu1yknf93rf3e]
09:06:52,835  INFO org.hibernate.tool.hbm2ddl.TableMetadata:70 - HHH000126: Indexes: [fk_fipu5nseny7muu1yknf93rf3e]
09:06:52,846  INFO org.hibernate.tool.hbm2ddl.TableMetadata:66 - HHH000261: Table found: hibernate.person_event
09:06:52,847  INFO org.hibernate.tool.hbm2ddl.TableMetadata:67 - HHH000037: Columns: [person_id, event_id]
09:06:52,847  INFO org.hibernate.tool.hbm2ddl.TableMetadata:69 - HHH000108: Foreign keys: [fk_8xsbl2jbyqaf5ocifr7hcjt2x, fk_7bh2i9xjn8v93x5ku5w61npwf]
09:06:52,848  INFO org.hibernate.tool.hbm2ddl.TableMetadata:70 - HHH000126: Indexes: [primary, fk_7bh2i9xjn8v93x5ku5w61npwf]
09:06:52,849  INFO org.hibernate.tool.hbm2ddl.SchemaUpdate:242 - HHH000232: Schema update complete
Hibernate: 
    select
        person0_.PERSON_ID as PERSON_I1_1_0_,
        person0_.age as age2_1_0_,
        person0_.firstname as firstnam3_1_0_,
        person0_.lastname as lastname4_1_0_ 
    from
        PERSON person0_ 
    where
        person0_.PERSON_ID=?
Hibernate: 
    select
        emailaddre0_.PERSON_ID as PERSON_I1_1_0_,
        emailaddre0_.EMAIL_ADDR as EMAIL_AD2_2_0_ 
    from
        PERSON_EMAIL_ADDR emailaddre0_ 
    where
        emailaddre0_.PERSON_ID=?
Hibernate: 
    select
        person0_.PERSON_ID as PERSON_I1_1_0_,
        event2_.EVENT_ID as EVENT_ID1_0_1_,
        person0_.age as age2_1_0_,
        person0_.firstname as firstnam3_1_0_,
        person0_.lastname as lastname4_1_0_,
        event2_.EVENT_DATE as EVENT_DA2_0_1_,
        event2_.title as title3_0_1_,
        events1_.PERSON_ID as PERSON_I2_1_0__,
        events1_.EVENT_ID as EVENT_ID1_3_0__ 
    from
        PERSON person0_ 
    left outer join
        PERSON_EVENT events1_ 
            on person0_.PERSON_ID=events1_.PERSON_ID 
    left outer join
        EVENTS event2_ 
            on events1_.EVENT_ID=event2_.EVENT_ID 
    where
        person0_.PERSON_ID=?
Hibernate: 
    update
        PERSON 
    set
        age=?,
        firstname=?,
        lastname=? 
    where
        PERSON_ID=?
Tests run: 2, Failures: 0, Errors: 0, Skipped: 0, Time elapsed: 1.942 sec

Results :

Tests run: 2, Failures: 0, Errors: 0, Skipped: 0

[INFO] ------------------------------------------------------------------------
[INFO] BUILD SUCCESS
[INFO] ------------------------------------------------------------------------
[INFO] Total time: 3.849 s
[INFO] Finished at: 2014-12-23T09:06:53+08:00
[INFO] Final Memory: 7M/18M
[INFO] ------------------------------------------------------------------------
这样就完成了Hibernate与maven的集成。在Hibernate中有一个比较重要的内容较Open Session in View。这里我们写一个Servlet进行简单的演示。

首先把我们当前的项目转换为web project。这步就不再赘述。

然后我们新建一个Servlet叫EventManagerServlet：

package com.smile.pansoft.mavenhibernate.web;

import java.io.IOException;
import java.io.PrintWriter;
import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.Iterator;
import java.util.List;

import javax.servlet.ServletException;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

import com.smile.pansoft.mavenhibernate.domains.Event;
import com.smile.pansoft.mavenhibernate.util.HibernateUtil;

//Imports

public class EventManagerServlet extends HttpServlet {

	protected void doGet(HttpServletRequest request,
			HttpServletResponse response) throws ServletException, IOException {

		SimpleDateFormat dateFormatter = new SimpleDateFormat("dd.MM.yyyy");

		try {
			// Begin unit of work
			HibernateUtil.getSessionFactory().getCurrentSession()
					.beginTransaction();

			// Process request and render page...
			// Write HTML header
			PrintWriter out = response.getWriter();
			out.println("<html><head><title>Event Manager</title></head><body>");

			// Handle actions
			if ("store".equals(request.getParameter("action"))) {

				String eventTitle = request.getParameter("eventTitle");
				String eventDate = request.getParameter("eventDate");

				if ("".equals(eventTitle) || "".equals(eventDate)) {
					out.println("<b><i>Please enter event title and date.</i></b>");
				} else {
					createAndStoreEvent(eventTitle,
							dateFormatter.parse(eventDate));
					out.println("<b><i>Added event.</i></b>");
				}
			}

			// Print page
			printEventForm(out);
			listEvents(out, dateFormatter);

			// Write HTML footer
			out.println("</body></html>");
			out.flush();
			out.close();

			// End unit of work
			HibernateUtil.getSessionFactory().getCurrentSession()
					.getTransaction().commit();
		} catch (Exception ex) {
			HibernateUtil.getSessionFactory().getCurrentSession()
					.getTransaction().rollback();
			if (ServletException.class.isInstance(ex)) {
				throw (ServletException) ex;
			} else {
				throw new ServletException(ex);
			}
		}
	}
	
	   private void printEventForm(PrintWriter out) {
	        out.println("<h2>Add new event:</h2>");
	        out.println("<form>");
	        out.println("Title: <input name='eventTitle' length='50'/><br/>");
	        out.println("Date (e.g. 24.12.2009): <input name='eventDate' length='10'/><br/>");
	        out.println("<input type='submit' name='action' value='store'/>");
	        out.println("</form>");
	    }
	   
	   private void listEvents(PrintWriter out, SimpleDateFormat dateFormatter) {

	        List result = HibernateUtil.getSessionFactory()
	                .getCurrentSession().createCriteria(Event.class).list();
	        if (result.size() > 0) {
	            out.println("<h2>Events in database:</h2>");
	            out.println("<table border='1'>");
	            out.println("<tr>");
	            out.println("<th>Event title</th>");
	            out.println("<th>Event date</th>");
	            out.println("</tr>");
	            Iterator it = result.iterator();
	            while (it.hasNext()) {
	                Event event = (Event) it.next();
	                out.println("<tr>");
	                out.println("<td>" + event.getTitle() + "</td>");
	                out.println("<td>" + dateFormatter.format(event.getDate()) + "</td>");
	                out.println("</tr>");
	            }
	            out.println("</table>");
	        }
	    }
	   
	   protected void createAndStoreEvent(String title, Date theDate) {
	        Event theEvent = new Event();
	        theEvent.setTitle(title);
	        theEvent.setDate(theDate);

	        HibernateUtil.getSessionFactory()
	                .getCurrentSession().save(theEvent);
	    }

}
这个Servlet包含了添加和展示的操作。

这时候我们在pom.xml中增加如下配置：

<packaging>war</packaging>
  
  <build>
  	<finalName>web-app-event</finalName>
  	<plugins>
  		<plugin>
  			<groupId>org.apache.maven.plugins</groupId>
			<artifactId>maven-war-plugin</artifactId>
			<version>2.5</version>
			<configuration>
				<outputDirectory>E:\SSH_Maven</outputDirectory>
			</configuration>
  		</plugin>
  	</plugins>
  </build>
表明我们打包整war包，默认是jar。

然后执行mvn install或者mvn package命令：

[INFO] --- maven-war-plugin:2.5:war (default-war) @ hibernate-tutorial ---
[INFO] Packaging webapp
[INFO] Assembling webapp [hibernate-tutorial] in [E:\SSH_Maven\maven-hibernate\target\web-app-event]
[INFO] Processing war project
[INFO] Copying webapp resources [E:\SSH_Maven\maven-hibernate\src\main\webapp]
[INFO] Webapp assembled in [125 msecs]
[INFO] Building war: E:\SSH_Maven\web-app-event.war
[INFO] 
[INFO] --- maven-install-plugin:2.4:install (default-install) @ hibernate-tutorial ---
[INFO] Installing E:\SSH_Maven\web-app-event.war to E:\Maven\m2\repository\org\hibernate\tutorials\hibernate-tutorial\1.0.0-SNAPSHOT\hibernate-tutorial-1.0.0-SNAPSHOT.war
[INFO] Installing E:\SSH_Maven\maven-hibernate\pom.xml to E:\Maven\m2\repository\org\hibernate\tutorials\hibernate-tutorial\1.0.0-SNAPSHOT\hibernate-tutorial-1.0.0-SNAPSHOT.pom
[INFO] ------------------------------------------------------------------------
[INFO] BUILD SUCCESS
[INFO] ------------------------------------------------------------------------
[INFO] Total time: 4.995 s
[INFO] Finished at: 2014-12-23T09:13:19+08:00
[INFO] Final Memory: 9M/22M
[INFO] ------------------------------------------------------------------------
war包就会直接打到我们制定的目录下。我们将war包拷贝到应用服务器下面，然后进行访问。

一个简单的添加展示界面就显示出来了。这也算是一个maven对Hibernate的web项目的集成吧。

maven整合hibernate注意事项或易错点
wordpython
07-12 303
本项目是在eclipse中完成，IDEA一样 一：路径问题（如图）： 解释： 1.创建一个空的hibernate.properties文件并且放在src/main/resources下，否则程序提示，但不影响程序正常运行：12:14:29.207 [main] INFO org.hibernate.cfg.Environment - HHH000206: hibernate.proper...
maven+spring+springmvc+hibernate整合
10-24
maven项目搭建的ssh(spring+springmvc+hibernate)框架整合的小demo，实现了基础的增删改查。仅供参考。
用Maven创建Hibernate项目
关于代码的那些事
04-05 2006
本文将用Maven3、Hibernate3.6、Oracle10g整合，作为例子。 环境清单： 1.Maven3.0.5 2.Hibernate3.6.5 Final 3.JDK1.7.0.11 4.Oracle10g 一.首先创建表BDUSER
Hibernate简介
最新发布
yuren_xia的博客
06-18 418
Hibernate 是一个开源的对象关系映射（ORM）框架，用于将 Java 对象映射到关系型数据库，简化数据库操作。它避免了直接编写 SQL 的繁琐，通过面向对象的方式操作数据。
使用maven 整合hibernate string struts
Hxp_0611的博客
08-04 176
1.创建一个java maven web项目，在pom.xml导入对应的核心架包 <!-- mysql核心架包 --> <!-- https://mvnrepository.com/artifact/mysql/mysql-connector-java --> <dependency> <groupId>mysql</groupId> <artifactId&
maven整合Struts2-Spring-Hibernate
云
01-22 310
pom.xml &amp;lt;project xmlns=&quot;http://maven.apache.org/POM/4.0.0&quot; xmlns:xsi=&quot;http://www.w3.org/2001/XMLSchema-instance&quot; xsi:schemaLocation=&quot;http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/ma...
Maven与Hibernate结合创建简单Java项目教程
标题“maven+hibernate项目简单示例”表明了本示例项目将演示如何在Java环境下使用Maven构建工具来搭建一个集成了Hibernate持久层框架的简单项目。Hibernate是一个流行的Java对象关系映射（ORM）框架，它使得开发者...
maven+hibernate
10-23
标题 "maven+hibernate" 暗示我们讨论的是使用 Maven 作为构建工具，与 Hibernate 这一流行的对象关系映射（ORM）框架整合的项目。在Java开发中，Maven 和 Hibernate 是两个非常重要的组件。Maven 用于自动化项目的...
使用Maven配置Hibernate5
07-13
本文将深入探讨如何结合Maven配置Hibernate5，以实现高效的数据访问层。 首先，要使用Hibernate5，你需要在Maven的`pom.xml`文件中添加相应的依赖。在`<dependencies>`标签内，加入以下代码： ```xml <groupId>...
maven项目hibernate demo
12-16
在本项目"maven项目hibernate demo"中，我们将探讨如何使用Maven构建Java应用程序，结合Hibernate ORM框架实现数据库操作。开发环境基于Java 1.7、Eclipse 4.5集成开发环境（IDE）以及Tomcat 6作为应用服务器，而...
Maven与Hibernate整合项目实践指南
在深入探讨如何将Maven与Hibernate结合之前，有必要了解Maven的基本知识。Maven项目通常遵循一种约定优于配置的策略，这意味着它有一套预设的目录结构和构建生命周期。一个典型的Maven项目结构包括： - src/main/...
用Maven整合SpringMVC+Spring+Hibernate 框架
09-28
用Maven整合Spring SpringMvc Hibernate 框架 ，仅实现简单的插入数据库数据功能。具体搭建地址: http://blog.youkuaiyun.com/js931178805/article/details/39642743
springmvc5+hibernate5+maven整合项目
07-31
SSH框架详细整合(Spring5+HIbernate5+Maven);maven：jar包管理仓库，方便引用可以打包，项目结构也比经典的WEB项目要清晰。
hibernate-entitymanager JAR包
04-16
hibernate EntityManager是围绕提供JPA编程接口的Hibernate Core的一个包装，支持JPA实体实例的生命周期，并允许你用标准的Java Persistence查询语言编写查询
HibernateUtil
04-02
HibernateUtil的相关封包------------------------------------------------------------------------------------------------------------------
第二章：Hibernate+注解+Maven，集成mysql
p812438109的专栏
08-03 1297
Hibernate maven环境搭建 一）创建一个maven project，项目名称叫xm-hibernate-maven，项目结构图如下： 二）pom.xml配置内容如下： &lt;project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-insta...
基于IDEA使用maven创建hibernate项目
m0_52116878的博客
08-23 1351
史上最全，手把手教你基于IDEA工具中，使用Maven构建使用hibernate做持久层框架的JavaWeb项目的新建过程。
基于maven搭建hibernate运行环境
weixin_30367543的博客
09-25 101
准备案例需要的数据库表和测试数据 建表语句： create table DEPARTMENT ( DEPT_ID integer not null, DEPT_NAME varchar(255) not null, DEPT_NO varchar(20) not null, LOCATION varchar(255), primary ke...
maven学习问题--HibernateUtil不能初始化
蓝色的风
10-18 1649
此文章只是记录自己学习的过程，而且最后也没搞明白是怎么回事，只是问题解决了。        在学习的孔浩老师的maven视频（在eclipse中搭建简单的项目）时，看完视频后我照着敲了一遍。        我把搭建这个easy的demo分为以下步骤：              1、创建maven项目，确定groupId, artifactId,version              2、
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值