使用hibernate的心得和踩过的坑

最新推荐文章于 2023-12-07 23:11:21 发布

LUNG108

最新推荐文章于 2023-12-07 23:11:21 发布

阅读量1k

点赞数

分类专栏： ssh

本文链接：https://blog.csdn.net/lung108/article/details/78133652

版权

ssh 专栏收录该内容

0 篇文章 0 订阅

订阅专栏

这一个月以来，尝试着使用了hibernate，主要是spring mvc，spring和hibernate的整合，以及使用@NamedQuery来建立查询条件（maven项目）

从配置好框架，到一次次启动报错时疯狂的搜索资料，感觉自己成长了很多。再最后一次看到页面显示出需要的数据时，有种舍我其谁的感觉（我知道我做的这些很多人早就掌握了）。但是自己心中的成就感就是抑制不住。

我因为算是一个新手，所以学习技术的出发点都是能够运行，能够正常使用。底层原理这一块研究的不多。

项目目录结构：

第一：springMVC + spring4 + hibernate4 的整合

（没使用实体类的映射文件，因为我感觉映射文件好麻烦）

离不开的文件是 web.xml，springContext*.xml，数据库连接文件（jdbc.properties）以及pom.xml

pom.xml：

<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/maven-v4_0_0.xsd">
  <modelVersion>4.0.0</modelVersion>
  <groupId>cn.lung</groupId>
  <artifactId>testssh</artifactId>
  <packaging>war</packaging>
  <version>0.0.1-SNAPSHOT</version>
  <name>testssh Maven Webapp</name>
  <url>http://maven.apache.org</url>
  
  	<properties>
		<spring.version>4.1.3.RELEASE</spring.version>
		<hibernate.version>4.1.1.Final</hibernate.version>
		<junit.version>4.6</junit.version>
		<jackson.version>1.9.13</jackson.version>
	</properties>
  
	<dependencies>
	<!-- spring -->
		<dependency>
			<groupId>org.springframework</groupId>
			<artifactId>spring-core</artifactId>
			<version>${spring.version}</version>
		</dependency>
		<dependency>
			<groupId>org.springframework</groupId>
			<artifactId>spring-context</artifactId>
			<version>${spring.version}</version>
		</dependency>
		<dependency>
			<groupId>org.springframework</groupId>
			<artifactId>spring-aop</artifactId>
			<version>${spring.version}</version>
		</dependency>
		<!-- 可以用于springMVC，如@RequestMapping -->
	   	<dependency>
			<groupId>org.springframework</groupId>
			<artifactId>org.springframework.web.servlet</artifactId>
			<version>3.1.1.RELEASE</version>
		</dependency>
		<!-- spring AOP功能依赖的包 -->
		<dependency>
		    <groupId>org.aspectj</groupId>
		    <artifactId>aspectjweaver</artifactId>
		    <version>1.8.10</version>
		</dependency>
		<dependency>
            		<groupId>org.springframework</groupId>
            		<artifactId>spring-orm</artifactId>
            		<version>${spring-version}</version>
        	</dependency>
		<!-- 可用于整合hibernate -->
		<dependency>
		    <groupId>org.springframework</groupId>
		    <artifactId>spring-orm</artifactId>
		    <version>${spring.version}</version>
		</dependency>
		<dependency>
			<groupId>org.springframework</groupId>
			<artifactId>spring-tx</artifactId>
			<version>${spring.version}</version>
		</dependency>
		 
	<!-- hibernate -->
		<dependency>
			<groupId>org.hibernate</groupId>
			<artifactId>hibernate-core</artifactId>
			<version>${hibernate.version}</version>
		</dependency>
		<dependency>
			<groupId>org.hibernate.javax.persistence</groupId>
			<artifactId>hibernate-jpa-2.0-api</artifactId>
			<version>1.0.1.Final</version>
		</dependency>
		
		
	<!-- mysql驱动 -->
		<dependency>
            		<groupId>mysql</groupId>
            		<artifactId>mysql-connector-java</artifactId>
            		<version>5.1.18</version>
        	</dependency>
        
    <!-- 工具包，如StringUtils -->
		<dependency>
			<groupId>org.apache.commons</groupId>
			<artifactId>commons-lang3</artifactId>
			<version>3.1</version>
		</dependency>
		
		<dependency>
			<groupId>junit</groupId>
			<artifactId>junit</artifactId>
			<version>${junit.version}</version>
		</dependency>
		
	<!-- c3p0 -->
		<dependency>
		    <groupId>c3p0</groupId>
		    <artifactId>c3p0</artifactId>
		    <version>0.9.1.2</version>
		</dependency>
		
	<!-- Jackson -->  
        	<dependency>  
		    <groupId>org.codehaus.jackson</groupId>  
		    <artifactId>jackson-core-lgpl</artifactId>  
		    <version>1.9.6</version>  
		</dependency>  
		<dependency>  
		    <groupId>org.codehaus.jackson</groupId>  
		    <artifactId>jackson-core-asl</artifactId>  
		    <version>1.9.4</version>  
		</dependency>  
		<dependency>  
		    <groupId>org.codehaus.jackson</groupId>  
		    <artifactId>jackson-mapper-asl</artifactId>  
		    <version>1.9.5</version>  
		</dependency>  
		<dependency>  
		    <groupId>org.codehaus.jackson</groupId>  
		    <artifactId>jackson-mapper-lgpl</artifactId>  
		    <version>1.9.6</version>  
		</dependency>  		
	</dependencies> 
 
 
  <build>
    	<finalName>testssh</finalName>
    	<plugins>
		 <plugin>
              		<groupId>org.apache.tomcat.maven</groupId>
              		<artifactId>tomcat7-maven-plugin</artifactId>
              		<configuration>
                  		<port>8009</port>
                  		<path>/</path>
              		</configuration>
              		<version>2.2</version>
         	</plugin>
	</plugins>
  </build>
</project>

这些依赖和我一开始在网上找的有些不一样，去掉了一些，也新加了一些。启动项目并且和前台交互数据是够了。其中build中用了tomcat的插件，这样就不用发布的tomcat服务器，而可以打包后直接运行了

web.xml：

<?xml version="1.0" encoding="UTF-8"?>
<web-app xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
	xmlns="http://java.sun.com/xml/ns/javaee"
	xsi:schemaLocation="http://java.sun.com/xml/ns/javaee http://java.sun.com/xml/ns/javaee/web-app_2_5.xsd"
	id="jt-manage" version="2.5">
	<display-name>flower</display-name>

	<context-param>
		<param-name>contextConfigLocation</param-name>
		<param-value>classpath:spring/applicationContext*.xml</param-value>
	</context-param>
	<!--Spring的ApplicationContext 载入 -->
	<listener>
		<listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
	</listener>

	<!-- 编码过滤器，以UTF8编码 -->
	<filter>
		<filter-name>encodingFilter</filter-name>
		<filter-class>org.springframework.web.filter.CharacterEncodingFilter</filter-class>
		<init-param>
			<param-name>encoding</param-name>
			<param-value>UTF8</param-value>
		</init-param>
	</filter>
	<filter-mapping>
		<filter-name>encodingFilter</filter-name>
		<url-pattern>/*</url-pattern>
	</filter-mapping>

	<!-- 配置SpringMVC -->
	<servlet>
		<servlet-name>springmvc</servlet-name>
		<servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
		<!-- 指定SpringMVC配置文件 -->
		<init-param>
			<param-name>contextConfigLocation</param-name>
			<param-value>classpath:spring/springMVC-config.xml</param-value>
		</init-param>
		<load-on-startup>1</load-on-startup>
	</servlet>

	<servlet-mapping>
		<servlet-name>springmvc</servlet-name>
		<url-pattern>/</url-pattern>
	</servlet-mapping>
	
	<welcome-file-list>
		<welcome-file>index.jsp</welcome-file>
	</welcome-file-list>

</web-app>

因为我把springContext.xml的内容分成了不同的 springContext 为前缀的文件，所以在加载时有个 * 。全部写在一个里面也可以

springContext*.xml：

核心的springContext.xml文件：

<beans xmlns="http://www.springframework.org/schema/beans"
	xmlns:context="http://www.springframework.org/schema/context" xmlns:p="http://www.springframework.org/schema/p"
	xmlns:aop="http://www.springframework.org/schema/aop" xmlns:tx="http://www.springframework.org/schema/tx"
	xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
	xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-4.0.xsd
	http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-4.0.xsd
	http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-4.0.xsd 
	http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-4.0.xsd
	http://www.springframework.org/schema/util http://www.springframework.org/schema/util/spring-util-4.0.xsd">
	<!-- 导入外部配置文件 -->
	<context:property-placeholder location="classpath:/jdbc.properties"/>
	
	<!-- 扫描包 -->
	<context:component-scan base-package="cn.lung"/>
	
	<!-- 数据源 -->
	<bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource">
		<property name="driverClass" value="${jdbc.driver}"></property>
		<property name="jdbcUrl" value="${jdbc.url}"></property>
		<property name="user" value="${jdbc.username}"></property>
		<property name="password" value="${jdbc.password}"></property>
	</bean>
</beans>

其中使用了c3p0数据库连接池，需要的jar包在后面的pom.xml文件中有

和事务相关的applicationContext-transaction.xml文件：

<beans xmlns="http://www.springframework.org/schema/beans"
	xmlns:context="http://www.springframework.org/schema/context" xmlns:p="http://www.springframework.org/schema/p"
	xmlns:aop="http://www.springframework.org/schema/aop" xmlns:tx="http://www.springframework.org/schema/tx"
	xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
	xsi:schemaLocation="http://www.springframework.org/schema/beans 
		http://www.springframework.org/schema/beans/spring-beans-4.0.xsd
		http://www.springframework.org/schema/context 
		http://www.springframework.org/schema/context/spring-context-4.0.xsd
		http://www.springframework.org/schema/aop 
		http://www.springframework.org/schema/aop/spring-aop-4.0.xsd 
		http://www.springframework.org/schema/tx 
		http://www.springframework.org/schema/tx/spring-tx-4.0.xsd
		http://www.springframework.org/schema/util 
		http://www.springframework.org/schema/util/spring-util-4.0.xsd">
		
	<!-- 定义事务管理器 -->
	<bean id="transactionManager"
		class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
		<property name="dataSource" ref="dataSource" />
	</bean>

	<!-- 定义事务策略 -->
	<tx:advice id="txAdvice" transaction-manager="transactionManager">
		<tx:attributes>

			<!-- 主库执行操作，事务传播行为定义为默认行为 -->
			<tx:method name="get*" propagation="REQUIRED" />
			<tx:method name="find*" propagation="REQUIRED" />
			<tx:method name="save*" propagation="REQUIRED" />
			<tx:method name="update*" propagation="REQUIRED" />
			<tx:method name="delete*" propagation="REQUIRED" />

			<!--其他方法使用默认事务策略 -->
			<tx:method name="*" />
		</tx:attributes>
	</tx:advice>

	<aop:config>
		<!-- 定义切面，所有的service的所有方法 -->
		<aop:pointcut id="txPointcut" expression="execution(* cn.lung.service.*.*(..))" />
		<!-- 应用事务策略到Service切面 -->
		<aop:advisor advice-ref="txAdvice" pointcut-ref="txPointcut"/>
	</aop:config>
	
	
</beans>

其中的事务传播行为，get*，find* 定义为REQUIRED，是因为hibernate4的新特性

和spring MVC相关的springMVC-conf.xml文件：

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
	xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:p="http://www.springframework.org/schema/p"
	xmlns:context="http://www.springframework.org/schema/context"
	xmlns:mvc="http://www.springframework.org/schema/mvc"
	xsi:schemaLocation="http://www.springframework.org/schema/beans 
		http://www.springframework.org/schema/beans/spring-beans.xsd
        http://www.springframework.org/schema/mvc 
        http://www.springframework.org/schema/mvc/spring-mvc-4.0.xsd
        http://www.springframework.org/schema/context 
        http://www.springframework.org/schema/context/spring-context-4.0.xsd">
        <!-- 字符串处理 -->
	    <bean id="stringHttpMessageConverter"
	        class="org.springframework.http.converter.StringHttpMessageConverter">  
           <property name="supportedMediaTypes" value="text/plain;charset=UTF-8" />
        </bean>  
        <!--json处理-->    
        <bean  id="mappingJacksonHttpMessageConverter"
            class="org.springframework.http.converter.json.MappingJacksonHttpMessageConverter">    
            <property name="supportedMediaTypes">    
                <list>    
                    <value>text/html;charset=UTF-8</value>    
                    <value>text/plain;charset=UTF-8</value>    
                </list>    
            </property>    
        </bean>    
        
        <bean class="org.springframework.web.servlet.mvc.annotation.AnnotationMethodHandlerAdapter">      
	        <property name="messageConverters">      
	            <list >      
	                <ref bean="stringHttpMessageConverter" />      
	                <ref bean="mappingJacksonHttpMessageConverter" />      
	            </list>      
	        </property>      
	    </bean> 
        
      <!-- mvc:annotation-driven使用注解功能 -->    
		<mvc:annotation-driven />    
      
      
      
      <!-- 配置扫描器，使MVC注解生效 -->  
      <context:component-scan base-package="cn.lung.controller"/>
      
      <!-- 试图解析器 -->  
      <bean class="org.springframework.web.servlet.view.InternalResourceViewResolver">
      	<property name="prefix" value="/WEB-INF/page/"/>
      	<property name="suffix" value=".jsp"/>
      </bean> 
        
        
       <!-- 处理静态资源被“/”拦截的问题 -->
      <mvc:default-servlet-handler/>
      
      	<!-- 文件上传解析器，错误，源码中调用文件上传解析器id必须是multipartResolver 
		<bean id="multipartResolver" class="org.springframework.web.multipart.commons.CommonsMultipartResolver">
			<property name="defaultEncoding" value="utf-8"/>
			<property name="maxUploadSize" value="10485760"/>
		</bean>-->
</beans>

其中如果想在MVC中向前台返回json格式（包括list，map什么的），需要在其中配置Jackson转换器：MappingJacksonHttpMessageConverter。

这里面有个小坑，有的是这样的MappingJackson2HttpMessageConverter。其中多了一个 2 。具体为什么我不清楚，一个不行就试试另外一个。再一个就是这些转换bean要配置在<mvc:annotation-driven />的上面。

至此，spring和spring MVC的整合结束，与之前ssm框架时是一样的。(springMVC的配置做了跟新，再最后的补充里面)

和hibernate相关文件springContext-hibernate.xml：

<beans xmlns="http://www.springframework.org/schema/beans"
	xmlns:context="http://www.springframework.org/schema/context" xmlns:p="http://www.springframework.org/schema/p"
	xmlns:aop="http://www.springframework.org/schema/aop" xmlns:tx="http://www.springframework.org/schema/tx"
	xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
	xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-4.0.xsd
	http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-4.0.xsd
	http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-4.0.xsd 
	http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-4.0.xsd
	http://www.springframework.org/schema/util http://www.springframework.org/schema/util/spring-util-4.0.xsd">
	
	<!-- 构造sqlSessionFactory -->
	<bean id="sessionFactory" class="org.springframework.orm.hibernate4.LocalSessionFactoryBean">
		<property name="dataSource" ref="dataSource"/>
        	<!-- 配置扫描的实体包(pojo) -->  
        	<property name="packagesToScan" value="cn.lung.pojo"></property>		
		
		<property name="hibernateProperties">  
            		<props>  
                		<prop key="hibernate.hbm2ddl.auto">${hibernate.hbm2ddl.auto}</prop>  
                		<prop key="hibernate.show_sql">${hibernate.show_sql}</prop>  
                		<prop key="hibernate.format_sql">${hibernate.format_sql}</prop>  
                		<prop key="hibernate.dialect">${hibernate.dialect}</prop>  
                		<prop key="hibernate.current_session_context_class">${hibernate.current_session_context_class}</prop>
            		</props>  
        	</property>  
	</bean>
	
	<!-- 配置Hibernate 的事物管理器 -->  
    	<bean id="transactionManager" class="org.springframework.orm.hibernate4.HibernateTransactionManager">  
        	<property name="sessionFactory" ref="sessionFactory"></property>  
    	</bean>
    <tx:annotation-driven transaction-manager="transactionManager"/>
	
</beans>

其中相关配置的类就要使用hibernate了，也就是把以前mybatis的东西都替换成hibernate相关。这里面也有一个小坑，在<prop>中最后一个key最好加上，其中的值在jdbc.properties文件中。后面有解释。

jdbc.properties：

jdbc.driver=com.mysql.jdbc.Driver
jdbc.url=jdbc:mysql://127.0.0.1:3306/test?useUnicode=true&characterEncoding=utf8&autoReconnect=true&allowMultiQueries=true
jdbc.username=xxxx
jdbc.password=xxxx

hibernate.dialect=org.hibernate.dialect.MySQLInnoDBDialect
hibernate.hbm2ddl.auto=update  
hibernate.show_sql=true  
hibernate.format_sql=false  
hibernate.current_session_context_class=org.springframework.orm.hibernate4.SpringSessionContext

其中包含了数据库连接的配置和hibernate的配置。最后一个值最好加上的原因是：hibernate4 中，只需要通过getCurrentSession()来获取session（spring的问题）。并且不同于hibernate3的是这个值在 3 中是thead或者那个什么（记不住了）。

好，至此，ssh框架的整合已经完毕。

第二：前台页面和后台数据交互

数据库（mysql）：新建表t_user，其中字段为 id（自增），u_name，age
后台：
实体类：User

package cn.lung.pojo;

import java.io.Serializable;
import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;
import javax.persistence.NamedQueries;
import javax.persistence.NamedQuery;
import javax.persistence.Table;


@SuppressWarnings("serial")
@Entity
@Table(name="t_user")
@NamedQueries({
	//自定义查询
	@NamedQuery(name = "User.findAll", query = "select o from User o")
	})
public class User implements Serializable{

	@Id
	@GeneratedValue(strategy=GenerationType.AUTO)
	private int id;
	
	@Column(name = "u_name")
	private String userName;
	
	private int age;
	
	@Override
	public String toString() {
		return "User [id=" + id + ", userName=" + userName + ", age=" + age + "]";
	}
	
	public int getId() {
		return id;
	}
	public void setId(int id) {
		this.id = id;
	}
	public String getUsername() {
		return userName;
	}
	public void setUsername(String userName) {
		this.userName = userName;
	}
	public int getAge() {
		return age;
	}
	public void setAge(int age) {
		this.age = age;
	}
		
}

其中一些注解：
@SuppressWarnings("serial") ：在User实现序列化接口后，会有警告线。纯粹是不想看到警告线才加的这个
@Entity ：识别该类为实体类的注解，常和@Table一起使用，其中有name属性可以指定对应表名。就这个地方把我坑的半死
@Table(name="t_user") ：指定数据库中对应表

我一开始的写法是@Entity(name="t_user")，结果在查询中使用原生sql是正常的，但是一旦换成@NameQuery就报错启动不了。无意间才试出来应该分开写
@NamedQuery ：定义具体的操作语句内容，hibernate会自动把结果集映射的该实体类中
其他注解经常使用就不记录了。

dao层：
BaseDao<T>定义：

package cn.lung.dao;

import java.io.Serializable;
import java.util.List;

import javax.annotation.Resource;

import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.springframework.stereotype.Repository;

@Repository
public class BaseDao<T> {

	@Resource
	private SessionFactory sessionFactory;
	
	//获取session
	protected Session getSession() {
		return sessionFactory.getCurrentSession();
	}
	
	/**
     * 保存数据
     */
    public void save(T t) {
        getSession().save(t);
    }

    /**
     * 删除数据
     */
    public void delete(Serializable id, Class<T> clazz) {
        T t = get(id, clazz);
        if (t != null)
            getSession().delete(t);
        else
            new RuntimeException("你要删除的数据不存在").printStackTrace();
        ;
    }

    /**
     * 更新数据
     */
    public void update(T t) {
        getSession().update(t);
    }

    /**
     * 根据ID查找数据
     */
    @SuppressWarnings("unchecked")
    public T get(Serializable id, Class<T> clazz) {
        return (T) getSession().get(clazz, id);
    }

    /**
     * 查找所有数据
     */
    @SuppressWarnings("unchecked")
    public List<T> getAll(Class<T> clazz) {
        return getSession().createQuery(clazz.toString()).list();
    }
}

其中使用了泛型，并且添加了@Repository。
接口UserDao定义：

package cn.lung.dao;

import java.util.List;

import cn.lung.pojo.User;

public interface UserDao {
	public List<User> findAll();
}

纯接口，只干定义的事
实现UserDaoImpl定义：

package cn.lung.dao;

import java.util.List;
import org.hibernate.Query;
import org.hibernate.Session;
import org.springframework.stereotype.Repository;
import cn.lung.pojo.User;
@Repository
public class UserDaoImpl extends BaseDao<User> implements UserDao{
	
	@SuppressWarnings("unchecked")
	public List<User> findAll() {
		Session session = getSession();
		Query query = session.getNamedQuery("User.findAll");
		
//		String sql = "select * from t_user";
//		Query query = session.createSQLQuery(sql);
		return (List<User>)query.list();
	}
}

它继承了BaseDao，实现了UserDao，其上有@Repository，其中使用了两种查询方式：NameQuery（自动查找User上定义的方法）和原生sql。

Service层：
接口BaseService<T>定义：

package cn.lung.service;

import java.io.Serializable;
import java.util.List;
import org.springframework.transaction.annotation.Transactional;

public interface BaseService<T> {

	/**
     * 保存数据
     */
    @Transactional
    public void save(T t);

    /**
     * 删除数据
     */
    @Transactional
    public void delete(Serializable id);

    /**
     * 更新数据
     */
    @Transactional
    public void update(T t);

    /**
     * 根据ID获取数据
     */
    public T get(Serializable id);

    /**
     * 获取所有的数据
     */
    public List<T> getAll();
}

实现BaseServiceImpl<T>定义：

package cn.lung.service;

import java.io.Serializable;
import java.lang.reflect.ParameterizedType;
import java.lang.reflect.Type;
import java.util.List;

import javax.annotation.Resource;

import cn.lung.dao.BaseDao;

public abstract class BaseServiceImpl<T> implements BaseService<T> {

	@Resource
	private BaseDao<T> baseDao;
	
	private Class<T> clazz;
	
	@SuppressWarnings({ "unchecked", "rawtypes" })
	public BaseServiceImpl(){
		Class cla = getClass();
		Type type = cla.getGenericSuperclass();
		if(type instanceof ParameterizedType){
			ParameterizedType pType = (ParameterizedType) type;
			clazz = (Class<T>) pType.getActualTypeArguments()[0];
		}
	}
	
	
	/*
     * 保存数据
     */
    @Override
    public void save(T t) {
        baseDao.save(t);
    }

    /*
     * 根据ID删除数据
     */
    @Override
    public void delete(Serializable id) {
        baseDao.delete(id, clazz);
    }

    /*
     * 更新数据
     */
    @Override
    public void update(T t) {
        baseDao.update(t);
    }

    /*
     * 根据ID获得数据
     */
    @Override
    public T get(Serializable id) {
        return baseDao.get(id, clazz);
    }

    /*
     * 获取所有的数据
     */
    @Override
    public List<T> getAll() {
        return baseDao.getAll(clazz);
    }
}

其实这接口和实现不要也行，因为UserDao的实现已经继承了BaseDao，需要的方法都可以直接调用。
接口UserService定义：

package cn.lung.service;
import java.util.List;
import cn.lung.pojo.User;

public interface UserService extends BaseService<User>{
	public List<User> findAllUsers();
	
}

实现UserServiceImpl定义：

package cn.lung.service;
import java.util.List;
import javax.annotation.Resource;
import org.springframework.stereotype.Service;
import cn.lung.dao.UserDao;
import cn.lung.dao.UserDaoImpl;
import cn.lung.pojo.User;

@Service
public class UserServiceImpl extends BaseServiceImpl<User> implements UserService{

	@Resource
	private UserDao userDao;
	
	@Override
	public List<User> findAllUsers() {
		return userDao.findAll();
	}
}

Controller层：
TestController：

package cn.lung.controller;

@Controller
@RequestMapping("/user")
public class TestController {
	
	@Resource
	private UserService userService;
	
	@RequestMapping("/save")
	public String saveView(User user){
		userService.save(user);
		return "jsps/testPage";
	}
	
	@RequestMapping(value="/{id}")
	@ResponseBody
	public String deleteUser(@PathVariable Integer id){
		userService.delete(id);
		System.out.println("删除了");
		return "删除成功";
	}
	
	@RequestMapping("list")
	@ResponseBody
	public List<User> listuser(){//自定义的查询方法，返回json格式
		return userService.findAllUsers();
	}
}

前台：

index.jsp:

<%@page pageEncoding="utf-8" %>
<html>
<head>
<meta charset="utf-8" />
<title>测试页面</title>
</head>
<body>
<h2>Hello World!</h2>
<form action="user/save" method="post">
姓名：<input name="username"/>
年龄：<input name="age"/>
<button type="submit">提 交</button>
</form>
</body>
</html>

testPage.jsp:

<%@ page language="java" contentType="text/html; charset=UTF-8" pageEncoding="UTF-8"%>
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
<title>测试页面</title>
</head>
<body>
加一个玩玩
</body>
</html>

页面效果：

首页：

提交后页面：

数据库存储：

调用自定义的查询方法(此时是NameQuery方式调用findAll方法)查看User的list;

到这算是第一阶段全部完成。第二阶段需要看具体的需求来增加后端功能，如：文件上传，按条件搜索等

总结：

1.该ssh框架搭建初期，因为对hibernate完全不懂，也没有版本的概念，只知道拿过来就运行，无头苍蝇。
2.网上的不少资料方法是对的，可是hibernate版本3和4还是有区别的，至于现在5早已经发布了，往后继续研究再追加文章。
3.可能的问题：
一、MappingJacksonHttpMessageConverter与MappingJackson2HttpMessageConverter的选择
二、session获取问题;hibernate3和4获取方式一样，但是配置不一样，上面提到了。而获取方法，如：openSession（）和getCurrentSession()也不同。
openSession()：每次获取的session都是一个新的，并且需要手动调用close()才能关闭。不能保证是同一个线程在操作数据
getCurrentSession()：获取的session都是同一个，并且系统自动维护，不需要单独写close方法。一般能保证是同一个线程。
三、映射实体类操作方法时，entity与table注解添加
四、MVC返回字符串与json格式数据。其中字符串我没成功，直接返回String类型，死活都是乱码。而json格式数据需要配置Jackson，
springMVC内部集成了Jackson。在配置时要避免可能出现的下载问题。（连IE都能正常显示，我使用的时qq浏览器始终是倔强的下载---下面的补充中已经更改）

暂时总结这些，需要跟新再添加