1、下载Hibernate3.0.jar,hibernate-annotations.jar,hibernate-commons-annotations.jar等包。
2、在src下新建applicationContext.xml和base-jdbc.properties文件其内容如下:
2.1——applicationContext.xml文件
<?xml version="1.0" encoding="utf-8"?>
<beans default-autowire="byType"
xmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xmlns:aop="http://www.springframework.org/schema/aop"
xmlns:tx="http://www.springframework.org/schema/tx"
xsi:schemaLocation="
http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-2.0.xsd
http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-2.0.xsd
http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-2.0.xsd">
<bean id="propertyConfigurer"
class="org.springframework.beans.factory.config.PropertyPlaceholderConfigurer">
<property name="locations">
<list>
<value>classpath:base-jdbc.properties</value>
</list>
</property>
</bean>
<!-- 连接MySql数据库配置 -->
<bean id="dataSource"
class="org.apache.commons.dbcp.BasicDataSource">
<property name="driverClassName">
<!-- <value>${jdbc.kpi.driverClassName}</value> -->
<value>${mysql.driver}</value>
</property>
<property name="url">
<!-- <value>${jdbc.kpi.url}</value> -->
<value>${mysql.url}</value>
</property>
<property name="username">
<!-- <value>${jdbc.kpi.username}</value> -->
<value>${mysql.username}</value>
</property>
<property name="password">
<!-- <value>${jdbc.kpi.password}</value> -->
<value>${mysql.password}</value>
</property>
</bean>
<bean id="sessionFactory"
class="org.springframework.orm.hibernate3.annotation.AnnotationSessionFactoryBean">
<property name="dataSource" ref="dataSource" />
<property name="hibernateProperties">
<props>
<prop key="hibernate.query.factory_class">
org.hibernate.hql.classic.ClassicQueryTranslatorFactory
</prop>
<prop key="hibernate.dialect">
<!-- org.hibernate.dialect.Oracle9iDialect -->
org.hibernate.dialect.MySQLDialect
</prop>
<prop key="hibernate.cache.use_query_cache">false</prop>
<prop key="hibernate.show_sql">true</prop>
</props>
</property>
<property name="annotatedClasses">
<list>
<value>com.test.myhibernate.user.dto.User</value>
</list>
</property>
</bean>
<bean id="UserDAO" class="com.test.myhibernate.user.dao.UserDAO">
<property name="sessionFactory" ref="sessionFactory"></property>
</bean>
</beans>
2.2——base-jdbc.properties文件
mysql.driver=com.mysql.jdbc.Driver
mysql.url=jdbc:mysql://localhost:3306/myuser
mysql.username=root
mysql.password=root
3、根据项目要求在模块目录下新建几个pagekage。分别是:action,dto,dao,util。
4、在dto中新建User.java。其内容如下:
package com.test.myhibernate.user.dto;
import java.io.Serializable;
import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.Id;
import javax.persistence.Table;
@Entity
@Table(name = "user")
public class User implements Serializable {
/**
*
*/
private static final long serialVersionUID = 1L;
@Id
@Column(name="id")
private long id;
@Column(name="username")
private String username;
@Column(name="password")
private String password;
@Column(name="name")
private String name;
@Column(name="age")
private long age;
@Column(name="sex")
private String sex;
@Column(name="birthday")
private String birthday;
public long getId() {
return id;
}
public void setId(long id) {
this.id = id;
}
public String getUsername() {
return username;
}
public void setUsername(String username) {
this.username = username;
}
public String getPassword() {
return password;
}
public void setPassword(String password) {
this.password = password;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public long getAge() {
return age;
}
public void setAge(long age) {
this.age = age;
}
public String getSex() {
return sex;
}
public void setSex(String sex) {
this.sex = sex;
}
public String getBirthday() {
return birthday;
}
public void setBirthday(String birthday) {
this.birthday = birthday;
}
}
5、在dao中新建一个接口UserInterface.java。其内容如下:
package com.test.myhibernate.user.dao;
import java.util.List;
import com.test.myhibernate.user.dto.User;
public interface UserInterface {
/**
* @deprecated 得到所有的用户对象
* @return
*/
public abstract List<User> getAllUser();
/**
* @deprecated 通过Id查询到一个User对象。
* @param id
* @return
*/
public abstract User getUserById(int id);
/**
* @deprecated 通过Id删除一个User对象
* @param id
* @return
*/
public abstract boolean deleteUserById(int id);
/**
* @deprecated 添加一个User记录
* @param user
* @return
*/
public abstract boolean addUser(User user);
/**
* @deprecated 修改一条记录
* @param user
* @return
*/
public abstract boolean updateUser(User user);
}
6、在dao中实现这个接口UserDAO.java。其内容如下:
package com.test.myhibernate.user.dao;
import java.util.ArrayList;
import java.util.List;
import org.springframework.dao.DataAccessException;
import org.springframework.orm.hibernate3.support.HibernateDaoSupport;
import com.test.myhibernate.user.dto.User;
public class UserDAO extends HibernateDaoSupport implements UserInterface {
@Override
public boolean addUser(User user) {
try {
super.getHibernateTemplate().save(user);
return true;
} catch (DataAccessException e) {
e.printStackTrace();
return false;
}
}
@Override
public boolean deleteUserById(int id) {
User user = getUserById(id);
try {
if (user != null) {
super.getHibernateTemplate().delete(user);
return true;
} else {
return false;
}
} catch (DataAccessException e) {
e.printStackTrace();
return false;
}
}
@Override
public List<User> getAllUser() {
List<User> list = new ArrayList<User>();
try{
list = (ArrayList<User>)super.getHibernateTemplate().find("from com.test.myhibernate.user.dto.User");
return list;
}catch (DataAccessException e) {
e.printStackTrace();
return null;
}
}
@Override
public User getUserById(int id) {
User user = null;
try{
user = (User)super.getHibernateTemplate().get(com.test.myhibernate.user.dto.User.class, new Long(id));
return user;
}
catch (DataAccessException e) {
e.printStackTrace();
return null;
}
}
@Override
public boolean updateUser(User user) {
try{
super.getHibernateTemplate().update(user);//update使用Session不能进行修改
return true;
}
catch (DataAccessException e) {
e.printStackTrace();
return false;
}
}
}
7、在action中新建一个测试类main.java。其内容如下:
package com.test.myhibernate.user.action;
import java.util.ArrayList;
import java.util.List;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
import com.test.myhibernate.user.dao.UserDAO;
import com.test.myhibernate.user.dto.User;
public class main {
/**
* @param args
*/
public static void main(String[] args) {
ApplicationContext app = new ClassPathXmlApplicationContext(
"applicationContext.xml");
UserDAO userDAO = (UserDAO) app.getBean("UserDAO");
User user = new User();
user.setAge(21);
user.setBirthday("1988-10-07");
user.setName("xiaoguang");
user.setPassword("xiaoguangguang");
user.setSex("M");
user.setUsername("xiaoguangla");
userDAO.addUser(user);
userDAO.deleteUserById(0);
List<User> list = new ArrayList<User>();
list = userDAO.getAllUser();
int size = list.size();
for(int i=0;i < size;i++)
{
System.out.println(list.get(i).getId());
}
user.setId(5);
user.setUsername("dingdang");
userDAO.updateUser(user);
User newUser = userDAO.getUserById(1);
System.out.println(newUser.getName());
}
}
分享到:
相关推荐
赠送jar包:hibernate-jpa-2.1-api-1.0.2.Final.jar; 赠送原API文档:hibernate-jpa-2.1-api-1.0.2.Final-javadoc.jar; 赠送源代码:hibernate-jpa-2.1-api-1.0.2.Final-sources.jar; 赠送Maven依赖信息文件:...
赠送jar包:hibernate-jpa-2.1-api-1.0.2.Final.jar; 赠送原API文档:hibernate-jpa-2.1-api-1.0.2.Final-javadoc.jar; 赠送源代码:hibernate-jpa-2.1-api-1.0.2.Final-sources.jar; 赠送Maven依赖信息文件:...
hibernate-jpa-2.1-api-1.0.0.final-sources.jar 源码 hibernate-jpa-2.1-api-1.0.0.final-sources.jar 源码
`hibernate-jpa-2.1-api-1.0.0.final.jar`是Hibernate对JPA 2.1规范的实现库,它使得开发者能够使用Hibernate的高效功能同时遵循JPA规范。 **1. Hibernate与JPA的关系** Hibernate最初作为一个独立的ORM框架,后来...
hibernate-jpa-2.0-api-1.0.1.Final-sources.jar hibernate jpa 源代码
Hibernate是一款流行的ORM框架,它允许开发者使用面向对象的编程方式来操作数据库。Hibernate通过JDBC驱动与MySQL交互,因此选择一个与Hibernate版本兼容的MySQL驱动至关重要。不兼容的驱动可能导致数据持久化问题、...
hibernate-jpa-2.0-api-1.0.1.Final.jar
而Hibernate对Java Persistence API (JPA) 的支持,使得开发者能够以更加面向对象的方式处理数据。本文将深入探讨`hibernate-jpa-2.1-api-1.0.0.Final.jar`这个库,了解其源码中的关键概念和API,并结合具体应用,...
使用Hibernate JPA,开发者可以利用注解驱动的编程模型,减少代码量,同时通过ORM机制,使得业务逻辑和数据访问层更加分离,提高了代码的可读性和可维护性。然而,需要注意的是,虽然ORM工具带来了便利,但也可能...
Hibernate作为JPA的一个实现,极大地简化了数据库操作,使得开发者能够以面向对象的方式处理数据,而无需关注底层SQL的复杂性。本篇文章将深入探讨Hibernate JPA的核心概念、主要功能及使用方法。 一、Hibernate ...
Hibernate是JPA的一个实现,提供了丰富的功能和灵活性,使得在Java应用中使用JPA更加方便。 **1. Hibernate与JPA的关系:** JPA 是一种规范,定义了如何在Java应用中管理和持久化数据。它为开发者提供了一套API,...
在Java开发中,Hibernate和JPA(Java Persistence API)是两种广泛使用的对象关系映射(ORM)框架,它们简化了与数据库交互的过程,使开发者可以使用面向对象的方式来操作数据。本教程将介绍如何使用Hibernate和JPA...
在本文中,我们将探讨如何将Hibernate与Java Persistence API (JPA) 结合使用。首先,我们需要了解JPA的基本概念。 **1. 什么是JPA?** Java Persistence API (JPA) 是Java平台上的一个标准接口,它定义了用来管理...
通过Hibernate,开发者可以使用面向对象的方式进行数据操作,提高代码的可读性和可维护性。在本资源包中,`antlr.jar`是Hibernate解析器,用于处理HQL(Hibernate Query Language);`dom4j.jar`是XML处理库,用于...
正确的使用方式是定义一个`@Table`注解,并在其中使用`indexes`属性来指定索引。 ```java @Entity @Table(name = "MyTable", indexes = { @Index(columnList = "my_column", name = "my_index") }) public ...
在IT行业中,构建一个基于Spring、SpringMVC、Hibernate和JPA的开发环境是常见的任务,这四个组件都是Java企业级应用开发中的重要工具。让我们深入探讨这些技术以及如何将它们整合在一起搭建一个完整的开发环境。 *...
《深入理解Hibernate JPA 2.1 API:源码解析》 在Java世界里,ORM(Object-Relational Mapping)框架的出现极大地简化了数据库操作,其中Hibernate作为一款强大的ORM工具,备受开发者青睐。本篇文章将重点围绕...
通过使用JPA,开发者可以避免直接编写SQL语句,而是通过面向对象的方式来处理数据。 2. **Hibernate与JPA的关系**:Hibernate是JPA的一个实现,它提供了更强大的功能,如二级缓存、查询语言HQL等。Hibernate-JPA则...
- **查询语言(Criteria API, JPQL)**:Hibernate JPA提供了JPQL(Java Persistence Query Language)和Criteria API两种查询方式,它们允许以面向对象的方式编写查询语句,而不是直接写SQL。 **3. MySQL数据库...