Maven配置SpringMVC4+Spring4+Hibernate4环境

参考地址：https://www.cnblogs.com/moy25/p/8520851.html

一、添加依赖

1、新建maven的web项目后，在pom.xml添加依赖信息，对应的groupId 、artifactId修改成自己新建的

<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>web-ssh</groupId> <artifactId>moyapp</artifactId> <packaging>war</packaging> <version>1.0-SNAPSHOT</version> <name>moyapp Maven Webapp</name> <url>http://maven.apache.org</url> <properties> <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding> <springVersion>4.3.0.RELEASE</springVersion> <jacksonVersion>2.9.3</jacksonVersion> <hibernateVersion>4.3.5.Final</hibernateVersion> <c3p0Version>0.9.5.2</c3p0Version> <mysqlVersion>5.1.38</mysqlVersion> <slf4jVersion>1.7.21</slf4jVersion> <log4jVersion>1.2.17</log4jVersion> <jstlVersion>1.2</jstlVersion> <servletApiVersion>3.1.0</servletApiVersion> <junitVersion>4.12</junitVersion> </properties> <dependencies> <!--junit 测试开始--> <dependency> <groupId>junit</groupId> <artifactId>junit</artifactId> <version>${junitVersion}</version> <scope>test</scope> </dependency> <!--junit 测试结束--> <!--Slf4j + Log4j日志依赖 开始--> <dependency> <groupId>org.slf4j</groupId> <artifactId>slf4j-api</artifactId> <version>${slf4jVersion}</version> </dependency> <dependency> <groupId>org.slf4j</groupId> <artifactId>slf4j-log4j12</artifactId> <version>${slf4jVersion}</version> </dependency> <dependency> <groupId>log4j</groupId> <artifactId>log4j</artifactId> <version>${log4jVersion}</version> </dependency> <!--Slf4j + Log4j日志依赖 结束--> <!--JavaEE web容器提供 开始--> <dependency> <groupId>javax.servlet</groupId> <artifactId>javax.servlet-api</artifactId> <version>${servletApiVersion}</version> <scope>provided</scope> </dependency> <!--JavaEE web容器提供 开始--> <!--Jsp 常用标签库依赖 开始--> <dependency> <groupId>javax.servlet</groupId> <artifactId>jstl</artifactId> <version>${jstlVersion}</version> <scope>runtime</scope> </dependency> <!--Jsp 常用标签库依赖 结束--> <!-- SpringMVC模块依赖 开始--> <dependency> <groupId>org.springframework</groupId> <artifactId>spring-webmvc</artifactId> <version>${springVersion}</version> </dependency> <dependency> <groupId>com.fasterxml.jackson.core</groupId> <artifactId>jackson-databind</artifactId> <version>${jacksonVersion}</version> </dependency> <!-- SpringMVC模块依赖 结束--> <!-- Hibernate模块依赖 开始--> <dependency> <groupId>org.hibernate</groupId> <artifactId>hibernate-core</artifactId> <version>${hibernateVersion}</version> </dependency> <!-- Hibernate模块依赖 结束--> <!--C3p0 数据库连接池依赖 开始--> <dependency> <groupId>com.mchange</groupId> <artifactId>c3p0</artifactId> <version>${c3p0Version}</version> </dependency> <!--C3p0 数据库连接池依赖 结束--> <!--Jdbc 驱动依赖 开始 --> <dependency> <groupId>mysql</groupId> <artifactId>mysql-connector-java</artifactId> <version>${mysqlVersion}</version> </dependency> <!--Jdbc 驱动依赖 结束 --> <!--Spring常用模块依赖 开始--> <dependency> <groupId>org.springframework</groupId> <artifactId>spring-aop</artifactId> <version>${springVersion}</version> </dependency> <dependency> <groupId>org.springframework</groupId> <artifactId>spring-aspects</artifactId> <version>${springVersion}</version> </dependency> <dependency> <groupId>org.springframework</groupId> <artifactId>spring-beans</artifactId> <version>${springVersion}</version> </dependency> <dependency> <groupId>org.springframework</groupId> <artifactId>spring-context</artifactId> <version>${springVersion}</version> </dependency> <dependency> <groupId>org.springframework</groupId> <artifactId>spring-context-support</artifactId> <version>${springVersion}</version> </dependency> <dependency> <groupId>org.springframework</groupId> <artifactId>spring-core</artifactId> <version>${springVersion}</version> </dependency> <dependency> <groupId>org.springframework</groupId> <artifactId>spring-jdbc</artifactId> <version>${springVersion}</version> </dependency> <dependency> <groupId>org.springframework</groupId> <artifactId>spring-orm</artifactId> <version>${springVersion}</version> </dependency> <dependency> <groupId>org.springframework</groupId> <artifactId>spring-tx</artifactId> <version>${springVersion}</version> </dependency> <dependency> <groupId>org.springframework</groupId> <artifactId>spring-test</artifactId> <version>${springVersion}</version> </dependency> <dependency> <groupId>org.springframework</groupId> <artifactId>spring-web</artifactId> <version>${springVersion}</version> </dependency> <!--Spring常用模块依赖结束--> </dependencies> <build> <finalName>moyapp</finalName> <plugins> <plugin> <groupId>org.apache.maven.plugins</groupId> <artifactId>maven-compiler-plugin</artifactId> <configuration> <source>1.8</source> <target>1.8</target> </configuration> </plugin> <plugin> <groupId>org.apache.tomcat.maven</groupId> <artifactId>tomcat7-maven-plugin</artifactId> <version>2.2</version> <configuration> <port>8080</port> <charset>${project.build.sourceEncoding}</charset> <server>tomcat7</server> </configuration> </plugin> </plugins> </build> </project>

2、个人使用的数据库是mysql，需要新建数据库moyapp

3、个人的项目信息结构

二、添加配置信息

1、在修改web.xml信息

<?xml version="1.0" encoding="UTF-8"?>
<web-app xmlns="http://xmlns.jcp.org/xml/ns/javaee" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://xmlns.jcp.org/xml/ns/javaee http://xmlns.jcp.org/xml/ns/javaee/web-app_3_1.xsd" version="3.1"> <!-- *** 初始化Spring容器开始 *** --> <listener> <listener-class>org.springframework.web.context.ContextLoaderListener</listener-class> </listener> <context-param> <param-name>contextConfigLocation</param-name> <param-value>classpath:spring.xml</param-value> </context-param> <!-- === 初始化Spring容器结束 === --> <!-- *** 初始化SpringMVC开始 *** --> <servlet> <servlet-name>springMVC</servlet-name> <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class> <init-param> <param-name>contextConfigLocation</param-name> <param-value>classpath:spring-mvc.xml</param-value> </init-param> <load-on-startup>1</load-on-startup> </servlet> <servlet-mapping> <servlet-name>springMVC</servlet-name> <url-pattern>*.do</url-pattern> </servlet-mapping> <!-- === 初始化SpringMVC结束 === --> </web-app>

2、在classpath下添加spring.xml文件，base-package属性值可以改成自己对应的项目基础包名

<?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: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.xsd http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop.xsd http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx.xsd"> <!-- *** 导入外部配置文件开始 *** --> <context:property-placeholder location="classpath:db.properties"/> <!-- === 导入外部配置文件结束 === --> <context:component-scan base-package="com.moy"/> <import resource="spring-mvc.xml"/> <import resource="spring-dao.xml"/> <import resource="spring-tx.xml"/> <import resource="spring-task.xml"/> </beans>

3、在classpath下添加spring-dao.xml，添加数据源配置，packagesToScan列出来的实体类包名可以换成自己的

<?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: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.xsd http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop.xsd http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx.xsd"> <!-- *** dataSource start *** --> <bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource"> <property name="driverClass" value="${jdbc.driverClass}"/> <property name="jdbcUrl" value="${jdbc.url}"/> <property name="user" value="${jdbc.username}"/> <property name="password" value="${jdbc.password}"/> </bean> <!-- === dataSource end === --> <!-- *** sessionFactory start *** --> <bean id="sessionFactory" class="org.springframework.orm.hibernate4.LocalSessionFactoryBean"> <property name="dataSource" ref="dataSource"></property> <property name="packagesToScan"> <list> <value>com.moy.*.*.entity</value> </list> </property> <property name="hibernateProperties"> <props> <prop key="hibernate.hbm2ddl.auto">update</prop> <prop key="hibernate.show_sql">true</prop> <prop key="hibernate.dialect">org.hibernate.dialect.MySQL5InnoDBDialect</prop> </props> </property> </bean> <!-- === sessionFactory end === --> </beans>

4、（可选）在classpath下添加spring-task.xml，添加定时任务信息，spring3之后，可以更简单配置定时任务

<?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:aop="http://www.springframework.org/schema/aop" xmlns:tx="http://www.springframework.org/schema/tx" xmlns:task="http://www.springframework.org/schema/task" xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop.xsd http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx.xsd http://www.springframework.org/schema/task http://www.springframework.org/schema/task/spring-task.xsd"> <task:annotation-driven/> <task:scheduled-tasks> <task:scheduled ref="testTaskService" method="printCurrentTime" cron="* * * * * ?"/> </task:scheduled-tasks> </beans>

5、在classpath下添加spring-tx.xml，添加事务配置信息，defaultPointcut的包名可以换成自己的

<?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: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.xsd http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop.xsd http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx.xsd"> <!-- *** transactionManager start *** --> <bean id="transactionManager" class="org.springframework.orm.hibernate4.HibernateTransactionManager"> <property name="sessionFactory" ref="sessionFactory"></property> </bean> <!-- === transactionManager end === --> <!-- *** 配置事务增强处理Bean,指定事务管理器 start *** --> <tx:advice id="txAdvice" transaction-manager="transactionManager"> <tx:attributes> <tx:method name="get*" read-only="true" propagation="REQUIRED"/> <tx:method name="load*" read-only="true" propagation="REQUIRED"/> <tx:method name="find*" read-only="true" propagation="REQUIRED"/> <tx:method name="list*" read-only="true" propagation="REQUIRED"/> <tx:method name="count*" read-only="true" propagation="REQUIRED"/> <tx:method name="query*" read-only="true" propagation="REQUIRED"/> <tx:method name="save*" propagation="REQUIRED"/> <tx:method name="update*" propagation="REQUIRED"/> <tx:method name="delete*" propagation="REQUIRED"/> <tx:method name="execute*" propagation="REQUIRED"/> <tx:method name="copy*" propagation="REQUIRED"/> <tx:method name="insert*" propagation="REQUIRED"/> </tx:attributes> </tx:advice> <!-- === 配置事务增强处理Bean,指定事务管理器 end === --> <!-- *** 配置一个切入点 start *** --> <aop:config> <aop:pointcut id="defaultPointcut" expression=" execution(* com.moy.*.*.dao.*Dao.*(..)) || execution(* com.moy.*.*.dao.*Support.*(..)) || execution(* com.moy.*.*.dao.*Service.*(..)) || execution(* com.moy.*.*.dao.*Impl.*(..)) || execution(* com.moy.*.*.dao.impl.*impl.*(..)) || execution(* com.moy.*.*.support.*Support.*(..)) || execution(* com.moy.*.*.support.*Impl.*(..)) || execution(* com.moy.*.*.support.impl.*Impl.*(..)) || execution(* com.moy.*.*.service.*Service.*(..)) || execution(* com.moy.*.*.service.*Impl.*(..)) || execution(* com.moy.*.*.service.impl.*Impl.*(..)) "/> <aop:advisor advice-ref="txAdvice" pointcut-ref="defaultPointcut"/> </aop:config> <!-- === 配置一个切入点 end === --> <!-- *** 开启事务控制的注解支持(不建议使用) start *** --> <tx:annotation-driven transaction-manager="transactionManager"/> <!-- === 开启事务控制的注解支持 end === --> </beans>

6、在classpath下添加spring-mvc.xml，配置spring-mvc信息

<?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:aop="http://www.springframework.org/schema/aop" xmlns:tx="http://www.springframework.org/schema/tx" 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/context http://www.springframework.org/schema/context/spring-context.xsd http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop.xsd http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx.xsd http://www.springframework.org/schema/mvc http://www.springframework.org/schema/mvc/spring-mvc.xsd"> <mvc:annotation-driven/> <mvc:default-servlet-handler/> <bean class="org.springframework.web.servlet.view.InternalResourceViewResolver"> <property name="viewClass" value="org.springframework.web.servlet.view.JstlView"/> <property name="prefix" value="/WEB-INF/jsp/"/> <property name="suffix" value=".jsp"/> </bean> <!--只扫描@Controller注解类,否则影响事务--> <context:component-scan base-package="com.moy" use-default-filters="false"> <context:include-filter type="annotation" expression="org.springframework.stereotype.Controller"/> </context:component-scan> </beans>

7、在classpath下添加db.properties ，配置数据库连接信息

jdbc.driverClass=com.mysql.jdbc.Driver
jdbc.url=jdbc:mysql://localhost:3306/moyapp?useSSL=false
jdbc.username=root
jdbc.password=123

8、（可选）在classpath下添加log4j.properties，配置日志信息

### 设置###
log4j.rootLogger=debug,stdout
### 输出信息到控制台 ###
log4j.appender.stdout=org.apache.log4j.ConsoleAppender
log4j.appender.stdout.Target=System.out
log4j.appender.stdout.layout=org.apache.log4j.PatternLayout
log4j.appender.stdout.layout.ConversionPattern=[%-5p] %d{yyyy-MM-dd HH:mm:ss,SSS} method:%l%n%m%n

三、添加应用代码

1、新建基础dao类，BaseProjectDao和实现类BaseProjectDao4Impl

package com.moy.moyapp.test.dao;

import org.hibernate.SessionFactory;

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

/**
 * [Project]:moy-gradle-project  <br/>
 * [Email]:[email protected]  <br/> * [Date]:2018/2/2 <br/> * [Description]: hibernate公共dao操作 <br/> * * @author YeXiangYang */ public interface BaseProjectDao { /** * 获取SessionFactory * * @return SessionFactory */ SessionFactory getSessionFactory(); /** * 根据ID加载实体 * * @param entityClazz 实体class * @param id 唯一主键 * @return 实体 */ <T> T get(Class<T> entityClazz, Serializable id); /** * 保存实体 * * @param entity 保存的实体 * @return 实体 */ <T> Serializable save(T entity); /** * 更新实体 * * @param entity 实体 */ <T> void update(T entity); /** * 更新或保持实体 * * @param entity 实体 */ <T> void saveOrUpdate(T entity); /** * 删除实体 * * @param entity 实体 */ <T> void delete(T entity); /** * 根据ID删除实体 * * @param entityClazz 实体class * @param id 唯一主键 */ <T> int delete(Class<T> entityClazz, Serializable id); /** * 删除多个实体根据map * * @param entityClazz * @param fieldDeleteMap * @param <T> */ <T> int deleteByMap(Class<T> entityClazz, Map<String, Object> fieldDeleteMap); /** * 获取该实体所有列表 * * @param entityClazz 实体class * @return 实体列表 */ <T> List<T> listAll(Class<T> entityClazz); /** * 获取实体列表，根据类字段的map映射成hql的where过滤<br/> * <pre> * 例如：实体类 * class A{ * String bField;//字段 * } * Map<String, Object> fieldFilterMap = HashMap<>(2); * fieldFilterMap.put("bField" , "ABC"); * findAllByEntity(A.class, Map<String, Object> fieldFilterMap); * 则映射成hql为：select en from A en where en.bField='ABC'查询 * </pre> * * @param entityClazz 实体class * @param fieldFilterMap 根据实体类的字段对应的值进行过滤 * @return 实体列表 */ <T> List<T> listByMap(Class<T> entityClazz, Map<String, Object> fieldFilterMap); /** * 获取实体总数 * * @param entityClazz 实体class * @return 总数 */ <T> long countAll(Class<T> entityClazz); /** * 获取实体总数 * * @param entityClazz * @param fieldFilterMap * @param <T> * @return */ <T> long countByMap(Class<T> entityClazz, Map<String, Object> fieldFilterMap); /** * 根据HQL语句查询实体 * * @param hql hql语句 * @return 实体列表 */ List<Object> queryByHql(String hql); /** * 根据带占位符参数HQL语句查询实体 * * @param hql hql语句,?0的方式设置占位符号 * 例如：from Entity where id = ?0 and name = ?1 * @param params 参数 * @return 数据列表 */ List<Object> queryByHql(String hql, Object... params); /** * 根据带占位符参数HQL语句查询实体 * * @param hql * @param map * @return */ List<Object> queryByHql(String hql, Map<String, Object> map); /** * 使用hql 语句进行分页查询操作 * * @param hql 需要查询的hql语句 * @param pageNo 查询第pageNo页的记录 * @param pageSize 每页需要显示的记录数 * @return 当前页的所有记录 */ List<Object> queryByHql(String hql, int pageNo, int pageSize); /** * 使用hql 语句进行分页查询操作 * * @param hql 需要查询的hql语句,?0的方式设置占位符号 * @param params 如果hql带占位符参数，params用于传入占位符参数 * 例如：From Entity where id = ?0 * @param pageNo 查询第pageNo页的记录 * @param pageSize 每页需要显示的记录数 * @return 当前页的所有记录 */ List<Object> queryByHql(String hql, int pageNo, int pageSize, Object... params); List<Object> queryByHql(String hql, int pageNo, int pageSize, Map<String, Object> params); /** * 使用sql语句进行查询操作 * * @param sql 需要查询的sql语句 * @return 返回查询数据 */ List<Map<String, Object>> queryBySql(String sql); /** * 使用sql语句进行查询操作 * * @param sql 需要查询的sql语句,,?0的方式设置占位符号. * @param params 如果sql带占位符参数，params用于传入占位符参数 * 例如：select * from table where id = :index0 and name = :index1 * @return 返回查询数据 */ List<Map<String, Object>> queryBySql(String sql, Object... params); /** * 使用sql语句进行查询操作 * * @param sql 需要查询的sql语句 * @param params 如果sql带占位符参数，params用于传入map结构的占位符参数 * @return 返回查询数据 */ List<Map<String, Object>> queryBySql(String sql, Map<String, Object> params); /** * 使用sql语句进行查询操作 * * @param sql 需要查询的sql语句 * @param pageNo 查询第pageNo页的记录 * @param pageSize 每页需要显示的记录数 * @return 当前页的所有记录 */ List<Map<String, Object>> queryBySqlAndPage(String sql, int pageNo, int pageSize); /** * 使用sql语句进行查询操作 * * @param sql 需要查询的sql语句 * @param pageNo 查询第pageNo页的记录 * @param pageSize 每页需要显示的记录数 * @param params 如果sql带占位符参数,?0的方式设置占位符号 * @return 当前页的所有记录 */ List<Map<String, Object>> queryBySqlAndPage(String sql, int pageNo, int pageSize, Object... params); /** * 使用sql语句进行查询操作 * * @param sql 需要查询的sql语句 * @param pageNo 查询第pageNo页的记录 * @param pageSize 每页需要显示的记录数 * @param map 如果sql带占位符参数，params用于传入map结构的占位符参数 * @return 当前页的所有记录 */ List<Map<String, Object>> queryBySqlAndPage(String sql, int pageNo, int pageSize, Map<String, Object> map); /** * 使用sql语句进行查询操作，返回唯一结果 * * @param sql 需要查询的sql语句 * @return 返回唯一结果 */ Object queryUniqueResult(String sql); /** * 使用sql语句进行查询操作，返回唯一结果 * * @param sql 需要查询的sql语句 * @param params 如果sql带占位符参数,?0的方式设置占位符号 * @return 返回唯一结果 */ Object queryUniqueResult(String sql, Object... params); /** * 使用sql语句进行查询操作，返回唯一结果 * * @param sql 需要查询的sql语句 * @param map 如果sql带占位符参数，传入map作为参数 * @return 返回唯一结果 */ Object queryUniqueResult(String sql, Map<String, Object> map); /** * 执行hql语句，返回变化的数量 * * @param hql hql语句 * @return 变化的数量 */ int executeHql(String hql); /** * 执行hql语句，返回变化的数量 * * @param hql hql语句 * @param params hql占位符参数，,?0的方式设置占位符号 * @return 变化的数量 */ int executeHql(String hql, Object... params); /** * 执行hql语句，返回变化的数量 * * @param hql hql语句 * @param map hql占位符参数,根据map的key和value设置参数 * @return 变化的数量 */ int executeHql(String hql, Map<String, Object> map); /** * 执行sql语句，返回变化的数量 * * @param sql sql语句 * @return 变化的数量 */ int executeSql(String sql); /** * 执行sql语句，返回变化的数量 * * @param sql sql语句 * @param params hql占位符参数，,?0的方式设置占位符号 * @return 变化的数量 */ int executeSql(String sql, Object... params); /** * 执行sql语句，返回变化的数量 * * @param sql sql语句 * @param map hql占位符参数,根据map的key和value设置参数 * @return 变化的数量 */ int executeSql(String sql, Map<String, Object> map); }

package com.moy.moyapp.test.dao.impl;

import com.moy.moyapp.test.dao.BaseProjectDao;
import org.hibernate.Query;
import org.hibernate.SQLQuery;
import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.hibernate.transform.Transformers;
import org.springframework.stereotype.Repository;

import javax.annotation.Resource;
import java.io.Serializable;
import java.util.*;

/**
 * [Project]:moy-gradle-project  <br/>
 * [Email]:[email protected]  <br/> * [Date]:2018/2/2 <br/> * [Description]: hibernate公共dao操作 <br/> * * @author YeXiangYang */ @Repository("baseProjectDao") public class BaseProjectDao4Impl implements BaseProjectDao { private static final Object[] EMPTY_OBJECT_ARRAY = {}; private static final Map<String, Object> EMPTY_MAP = Collections.EMPTY_MAP; @Resource private SessionFactory sessionFactory; @Override public SessionFactory getSessionFactory() { return sessionFactory; } private Session getSession() { return getSessionFactory().getCurrentSession(); } @SuppressWarnings("unchecked") @Override public <T> T get(Class<T> entityClazz, Serializable id) { return (T) getSession().get(entityClazz, id); } @Override public <T> Serializable save(T entity) { return getSession().save(entity); } @Override public <T> void update(T entity) { getSession().update(entity); } public <T> void saveOrUpdate(T entity) { getSession().saveOrUpdate(entity); } @Override public <T> void delete(T entity) { getSession().delete(entity); } @Override public <T> int delete(Class<T> entityClazz, Serializable id) { Map<String, Object> fieldFilterMap = new HashMap<>(2); fieldFilterMap.put("id", id); return deleteByMap(entityClazz, fieldFilterMap); } @Override public <T> int deleteByMap(Class<T> entityClazz, Map<String, Object> fieldDeleteMap) { StringBuilder sb = buildHql("DELETE ", entityClazz.getSimpleName(), " en WHERE 1 = 1 "); appendEqualsCondition(fieldDeleteMap, sb); Query query = getSession().createQuery(sb.toString()); setParamsByMap(fieldDeleteMap, query); return query.executeUpdate(); } /** * 追加equals条件 * * @param fieldFilterMap 类字段参数map * @param sb hql语句 */ private void appendEqualsCondition(Map<String, Object> fieldFilterMap, StringBuilder sb) { if (null != fieldFilterMap) { for (Map.Entry<String, Object> en : fieldFilterMap.entrySet()) { String key = en.getKey().trim(); sb.append(" and en.").append(key); sb.append(" = :").append(key); } } } @Override public <T> List<T> listAll(Class<T> entityClazz) { return listByMap(entityClazz, EMPTY_MAP); } @SuppressWarnings("unchecked") public <T> List<T> listByMap(Class<T> entityClazz, Map<String, Object> fieldFilterMap) { StringBuilder sb = buildHql("FROM ", entityClazz.getSimpleName(), " en WHERE 1 = 1 "); appendEqualsCondition(fieldFilterMap, sb); Query query = getSession().createQuery(sb.toString()); setParamsByMap(fieldFilterMap, query); return (List<T>) query.list(); } @Override public <T> long countAll(Class<T> entityClazz) { return countByMap(entityClazz, null); } @Override public <T> long countByMap(Class<T> entityClazz, Map<String, Object> fieldFilterMap) { StringBuilder sb = buildHql("SELECT COUNT(*) FROM ", entityClazz.getSimpleName(), " en WHERE 1 = 1 "); appendEqualsCondition(fieldFilterMap, sb); List<?> l = queryByHql(sb.toString(), fieldFilterMap); if (null != l && 1 == l.size()) { return (Long) l.get(0); } return 0; } @Override public List<Object> queryByHql(String hql) { return queryByHql(hql, EMPTY_OBJECT_ARRAY); } @SuppressWarnings("unchecked") @Override public List<Object> queryByHql(String hql, Object... params) { Query query = getSession().createQuery(hql); setParamsByArray(query, params); return query.list(); } @Override public List<Object> queryByHql(String hql, Map<String, Object> map) { Query query = getSession().createQuery(hql); setParamsByMap(map, query); return query.list(); } @Override public List<Object> queryByHql(String hql, int pageNo, int pageSize) { return queryByHql(hql, pageNo, pageSize, EMPTY_OBJECT_ARRAY); } @SuppressWarnings("unchecked") @Override public List<Object> queryByHql(String hql, int pageNo, int pageSize, Object... params) { Query query = getSession().createQuery(hql); setPageParam(pageNo, pageSize, query); setParamsByArray(query, params); return (List<Object>) query.list(); } @Override public List<Object> queryByHql(String hql, int pageNo, int pageSize, Map<String, Object> params) { Query query = getSession().createQuery(hql); setPageParam(pageNo, pageSize, query); setParamsByMap(params, query); return (List<Object>) query.list(); } @Override public List<Map<String, Object>> queryBySql(String sql) { return queryBySql(sql, EMPTY_OBJECT_ARRAY); } @SuppressWarnings("unchecked") @Override public List<Map<String, Object>> queryBySql(String sql, Object... params) { SQLQuery sqlQuery = getSession().createSQLQuery(sql); sqlQuery.setResultTransformer(Transformers.ALIAS_TO_ENTITY_MAP); setParamsByArray(sqlQuery, params); return (List<Map<String, Object>>) sqlQuery.list(); } public List<Map<String, Object>> queryBySql(String sql, Map<String, Object> map) { SQLQuery sqlQuery = getSession().createSQLQuery(sql); sqlQuery.setResultTransformer(Transformers.ALIAS_TO_ENTITY_MAP); setParamsByMap(map, sqlQuery); return (List<Map<String, Object>>) sqlQuery.list(); } @Override public List<Map<String, Object>> queryBySqlAndPage(String sql, int pageNo, int pageSize) { return queryBySqlAndPage(sql, pageNo, pageSize, EMPTY_OBJECT_ARRAY); } @SuppressWarnings("unchecked") @Override public List<Map<String, Object>> queryBySqlAndPage(String sql, int pageNo, int pageSize, Object... params) { SQLQuery sqlQuery = getSession().createSQLQuery(sql); sqlQuery.setResultTransformer(Transformers.ALIAS_TO_ENTITY_MAP); setPageParam(pageNo, pageSize, sqlQuery); setParamsByArray(sqlQuery, params); return (List<Map<String, Object>>) sqlQuery.list(); } public List<Map<String, Object>> queryBySqlAndPage(String sql, int pageNo, int pageSize, Map<String, Object> map) { SQLQuery sqlQuery = getSession().createSQLQuery(sql); sqlQuery.setResultTransformer(Transformers.ALIAS_TO_ENTITY_MAP); setPageParam(pageNo, pageSize, sqlQuery); setParamsByMap(map, sqlQuery); return (List<Map<String, Object>>) sqlQuery.list(); } @Override public Object queryUniqueResult(String sql) { return queryUniqueResult(sql, EMPTY_OBJECT_ARRAY); } @Override public Object queryUniqueResult(String sql, Object... params) { SQLQuery sqlQuery = getSession().createSQLQuery(sql); setParamsByArray(sqlQuery, params); return sqlQuery.uniqueResult(); } @Override public Object queryUniqueResult(String sql, Map<String, Object> map) { SQLQuery sqlQuery = getSession().createSQLQuery(sql); setParamsByMap(map, sqlQuery); return sqlQuery.uniqueResult(); } @Override public int executeHql(String hql) { return executeHql(hql, EMPTY_OBJECT_ARRAY); } @Override public int executeHql(String hql, Object... params) { Query query = getSession().createQuery(hql); setParamsByArray(query, params); return query.executeUpdate(); } @Override public int executeHql(String hql, Map<String, Object> map) { Query query = getSession().createQuery(hql); setParamsByMap(map, query); return query.executeUpdate(); } @Override public int executeSql(String sql) { return executeSql(sql, EMPTY_OBJECT_ARRAY); } @Override public int executeSql(String sql, Object... params) { Query query = getSession().createSQLQuery(sql); setParamsByArray(query, params); return query.executeUpdate(); } @Override public int executeSql(String sql, Map<String, Object> map) { Query query = getSession().createSQLQuery(sql); setParamsByMap(map, query); return query.executeUpdate(); } /** * 根据数组设置org.hibernate.Query查询参数，?0的方式设置占位符号 * * @param query org.hibernate.Query * @param array 数组 */ private void setParamsByArray(Query query, Object[] array) { if (null != array) { for (int i = 0, len = array.length; i < len; i++) { query.setParameter(String.valueOf(i), array[i]); } } } private StringBuilder buildHql(String keyword, String className, String where) { StringBuilder sb = new StringBuilder(keyword); sb.append(className).append(where); return sb; } /** * 设置分页参数 * * @param pageNo 第几页 * @param pageSize 每页多少数目 * @param query org.hibernate.Query */ private void setPageParam(int pageNo, int pageSize, Query query) { query.setFirstResult((pageNo - 1) * pageSize); query.setMaxResults(pageSize); } /** * 根据map的key和value设置org.hibernate.Query查询参数 * * @param map map * @param query org.hibernate.Query */ private void setParamsByMap(Map<String, Object> map, Query query) { if (null != query && null != map && map.size() > 0) { for (Map.Entry<String, Object> each : map.entrySet()) { String key = each.getKey(); Object value = each.getValue(); if (null == value) { query.setParameter(key, value); } else if (value.getClass().isArray()) { query.setParameterList(key, (Object[]) value); } else if (value instanceof Collection) { query.setParameterList(key, (Collection) value); } else { query.setParameter(key, value); } } } } }

2、新建实体类TestEntity　　

package com.moy.moyapp.test.entity;

import javax.persistence.*;
import java.io.Serializable;
import java.util.Date;
import java.util.UUID;

/**
 * [Project]:moy-gradle-project  <br/>
 * [Email]:[email protected]  <br/> * [Date]:2018/2/2 <br/> * [Description]: <br/> * * @author YeXiangYang */ @Entity @Table(name = "t_test") public class TestEntity implements Serializable { private static final long serialVersionUID = 8530202658667667146L; @Id @GeneratedValue(strategy = GenerationType.IDENTITY) private Integer id; @Column(name = "gtm_create") private Date gtmCreate; @Column(name = "gtm_modified") private Date gtmModified; @Column(name = "description") private String desc; public TestEntity() { } public static TestEntity createInstance() { TestEntity test = new TestEntity(); test.setGtmCreate(new Date()); test.setGtmModified(new Date()); test.setDesc("测试数据描述:[" + UUID.randomUUID() + "]"); return test; } public Integer getId() { return id; } public void setId(Integer id) { this.id = id; } public Date getGtmCreate() { return gtmCreate; } public void setGtmCreate(Date gtmCreate) { this.gtmCreate = gtmCreate; } public Date getGtmModified() { return gtmModified; } public void setGtmModified(Date gtmModified) { this.gtmModified = gtmModified; } public String getDesc() { return desc; } public void setDesc(String desc) { this.desc = desc; } @Override public String toString() { return "TestEntity{" + "id=" + id + ", gtmCreate=" + gtmCreate + ", gtmModified=" + gtmModified + ", desc='" + desc + '\'' + '}'; } }

3、新建基础服务类BaseProjectService和实现类BaseProjectServiceImpl

package com.moy.moyapp.test.service;


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

/**
 * [Project]:moy-gradle-project  <br/>
 * [Email]:[email protected]  <br/> * [Date]:2018/2/2 <br/> * [Description]: 简化操作，项目基础Service类 <br/> * * @author YeXiangYang */ public interface BaseProjectService<E> { /** * 保存 */ Serializable save(E entity); /** * 删除根据id */ int delete(Serializable id); /** * 删除根据map条件 */ int deleteByMap(Map<String, Object> fieldFilterMap); /** * 删除 */ void delete(E entity); /** * 删除根据实体类 */ void update(E entity); /** * 保存或者更新 */ void saveOrUpdate(E entity); /** * 查询根据id */ E get(Serializable id); /** * 查询所有 */ List<E> listAll(); /** * 查询根据map条件 */ List<E> listByMap(Map<String, Object> fieldFilterMap); /** * 查询个数 */ long countAll(); /** * 查询个数根据map条件 */ long countByMap(Map<String, Object> fieldFilterMap); }

package com.moy.moyapp.test.service.impl;


import com.moy.moyapp.test.dao.BaseProjectDao;
import com.moy.moyapp.test.service.BaseProjectService;

import javax.annotation.Resource;
import java.io.Serializable;
import java.lang.reflect.ParameterizedType;
import java.util.List;
import java.util.Map;

/**
 * [Project]:moy-gradle-project  <br/>
 * [Email]:[email protected]  <br/> * [Date]:2018/2/2 <br/> * [Description]: 简化操作，项目基础Service类 <br/> * * @author YeXiangYang */ public abstract class BaseProjectServiceImpl<E> implements BaseProjectService<E> { @Resource protected BaseProjectDao baseProjectDao; protected final Class<E> clazz; { try { ParameterizedType parameterizedType = (ParameterizedType) this.getClass().getGenericSuperclass(); clazz = (Class<E>) parameterizedType.getActualTypeArguments()[0]; } catch (Exception e) { throw new RuntimeException("未声明实体泛型,继承BaseService需要按照规范!!!"); } } @Override public Serializable save(E entity) { return baseProjectDao.save(entity); } @Override public int delete(Serializable id) { return baseProjectDao.delete(clazz, id); } @Override public int deleteByMap(Map<String, Object> fieldFilterMap) { return baseProjectDao.deleteByMap(clazz, fieldFilterMap); } @Override public void delete(E entity) { baseProjectDao.delete(entity); } @Override public void update(E entity) { baseProjectDao.update(entity); } @Override public void saveOrUpdate(E entity) { baseProjectDao.saveOrUpdate(entity); } @Override public E get(Serializable id) { return baseProjectDao.get(clazz, id); } @Override public List<E> listAll() { return baseProjectDao.listAll(clazz); } @Override public List<E> listByMap(Map<String, Object> fieldFilterMap) { return baseProjectDao.listByMap(clazz, fieldFilterMap); } @Override public long countAll() { return baseProjectDao.countAll(clazz); } @Override public long countByMap(Map<String, Object> fieldFilterMap) { return baseProjectDao.countByMap(clazz, fieldFilterMap); } }

4、新建操作实体TestEntity的服务类TestService，和实现类TestServiceImpl

package com.moy.moyapp.test.service;


import com.moy.moyapp.test.entity.TestEntity;

/**
 * [Project]:moy-gradle-project  <br/>
 * [Email]:[email protected]  <br/> * [Date]:2018/2/4 <br/> * [Description]: <br/> * * @author YeXiangYang */ public interface TestService extends BaseProjectService<TestEntity> { void saveTxTest(); }

package com.moy.moyapp.test.service.impl;

import com.moy.moyapp.test.entity.TestEntity;
import com.moy.moyapp.test.service.TestService;
import org.springframework.stereotype.Service;

/**
 * [Project]:moy-gradle-project  <br/>
 * [Email]:[email protected]  <br/> * [Date]:2018/2/4 <br/> * [Description]: <br/> * * @author YeXiangYang */ @Service public class TestServiceImpl extends BaseProjectServiceImpl<TestEntity> implements TestService { @Override public void saveTxTest() { TestEntity instance = TestEntity.createInstance(); instance.setDesc("在事务下，我保存不上"); save(instance); int i = 1 / 0; } }

5、（可选）新建定时任务测试类TestTaskServiceImpl

package com.moy.moyapp.test.task;

import org.springframework.stereotype.Component;

import java.text.SimpleDateFormat;
import java.util.Date;

/**
 * [Project]:moy-gradle-project  <br/>
 * [Email]:[email protected]  <br/> * [Date]:2018/3/6 <br/> * [Description]: <br/> * * @author YeXiangYang */ @Component("testTaskService") public class TestTaskServiceImpl { public void printCurrentTime() { SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss"); System.out.println(sdf.format(new Date())); } }

6、新建TestController

package com.moy.moyapp.test.controller;

import com.moy.moyapp.test.entity.TestEntity;
import com.moy.moyapp.test.service.TestService;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.ResponseBody;

import javax.annotation.Resource;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.Serializable;

/**
 * [Project]:moy-gradle-project  <br/>
 * [Email]:[email protected]  <br/> * [Date]:2018/2/4 <br/> * [Description]: <br/> * * @author YeXiangYang */ @Controller @RequestMapping("/test") public class TestController { @Resource TestService testService; @RequestMapping("/save") @ResponseBody public Serializable save(HttpServletRequest request, HttpServletResponse response) { TestEntity instance = TestEntity.createInstance(); return testService.save(instance); } @ResponseBody @RequestMapping("/saveTxTest") public String saveTxTest(HttpServletRequest request, HttpServletResponse response) { try { testService.saveTxTest(); } catch (Exception e) { return e.getMessage(); } return "success"; } }

7、在WEB-INF同级目录添加index.jsp

<%@ page contentType="text/html;charset=UTF-8" language="java" %> <html> <head> <title>Test</title> </head> <% String contextPath = request.getContextPath(); %> <body> <a href="<%=contextPath%>/test/save.do">save</a><br/> <a href="<%=contextPath%>/test/saveTxTest.do">saveTxTest</a><br/> </body> </html>

四、测试

1、测试dao类BaseProjectDao4ImplTest

package com.moy.moyapp.test.dao.impl;

import com.moy.moyapp.test.dao.BaseProjectDao;
import com.moy.moyapp.test.entity.TestEntity;
import org.hibernate.SessionFactory;
import org.junit.After;
import org.junit.Before;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;

import javax.annotation.Resource;
import java.io.Serializable;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

/**
 * [Project]:moy-gradle-project  <br/>
 * [Email]:[email protected]  <br/> * [Date]:2018/2/3 <br/> * [Description]: <br/> * * @author YeXiangYang */ @RunWith(SpringJUnit4ClassRunner.class) @ContextConfiguration("/spring.xml") public class BaseProjectDao4ImplTest { @Resource BaseProjectDao baseProjectDao; Logger logger = LoggerFactory.getLogger(getClass()); long beforeTime; long afterTime; @Before public void before() { logger.info(this.toString()); beforeTime = System.currentTimeMillis(); logger.info("test method before : {}ms", beforeTime); } @After public void After() { afterTime = System.currentTimeMillis(); logger.info("test method After : {}ms", afterTime); logger.info("total time : {}ms", afterTime - beforeTime); } @Test public void getSessionFactory() { SessionFactory sessionFactory = baseProjectDao.getSessionFactory(); logger.info(sessionFactory.toString()); } @Test public void getTest() { TestEntity saveEntity = TestEntity.createInstance(); logger.info(saveEntity.toString()); Serializable save = baseProjectDao.save(saveEntity); logger.info(save.toString()); TestEntity testEntity = baseProjectDao.get(TestEntity.class, saveEntity.getId()); logger.info(testEntity.toString()); } @Test public void saveTest() { TestEntity test = TestEntity.createInstance(); baseProjectDao.save(test); } @Test public void updateTest() { TestEntity testEntity = TestEntity.createInstance(); logger.info(testEntity.toString()); logger.info(baseProjectDao.save(testEntity).toString()); testEntity.setGtmModified(null); testEntity.setDesc("修改后"); baseProjectDao.update(testEntity); } @Test public void saveOrUpdateTest() { TestEntity testEntity = TestEntity.createInstance(); baseProjectDao.saveOrUpdate(testEntity); testEntity.setDesc("保存或修改"); baseProjectDao.saveOrUpdate(testEntity); } @Test public void deleteTest() { TestEntity testEntity = TestEntity.createInstance(); Serializable id = baseProjectDao.save(testEntity); logger.info("" + baseProjectDao.delete(TestEntity.class, id)); baseProjectDao.save(testEntity); baseProjectDao.delete(testEntity); } @Test public void deleteByMapTest() { TestEntity testEntity = TestEntity.createInstance(); baseProjectDao.save(testEntity); HashMap param = new HashMap(); param.put("desc", testEntity.getDesc()); logger.info(String.valueOf(baseProjectDao.deleteByMap(TestEntity.class, param))); } @Test public void listAllTest() { List<TestEntity> list = baseProjectDao.listAll(TestEntity.class); printList(list); } @Test public void listByMapTest() { TestEntity testEntity = TestEntity.createInstance(); baseProjectDao.save(testEntity); Map param = new HashMap(); param.put("desc", testEntity.getDesc()); List<TestEntity> list = baseProjectDao.listByMap(TestEntity.class, param); printList(list); } private void printList(List list) { if (null != list) { for (Object each : list) { logger.info(each.toString()); } } } @Test public void countAllTest() { long count = baseProjectDao.countAll(TestEntity.class); logger.info(String.valueOf(count)); } @Test public void countByMapTest() { TestEntity testEntity = TestEntity.createInstance(); baseProjectDao.save(testEntity); Map param = new HashMap(); param.put("desc", testEntity.getDesc()); long count = baseProjectDao.countByMap(TestEntity.class, param); logger.info(String.valueOf(count)); } @Test public void queryByHqlTest() { String hql = "from TestEntity"; List<Object> list = baseProjectDao.queryByHql(hql); printList(list); TestEntity testEntity = TestEntity.createInstance(); Serializable id = baseProjectDao.save(testEntity); String hqlByListParam = hql + " where id = ?0"; Object[] objects = {id}; List<Object> hqlByListParamList = baseProjectDao.queryByHql(hqlByListParam, objects); printList(hqlByListParamList); List<Object> hqlByListParamListPage = baseProjectDao.queryByHql(hqlByListParam, 0, 5, objects); printList(hqlByListParamListPage); String hqlByListMap = hql + " where id = :id"; Map<String, Object> param = new HashMap<>(); param.put("id", id); List<Object> hqlByListMapList = baseProjectDao.queryByHql(hqlByListMap, param); printList(hqlByListMapList); List<Object> hqlByListMapListPage = baseProjectDao.queryByHql(hqlByListMap, 0, 5, param); printList(hqlByListMapListPage); } @Test public void queryBySqlTest() { String sql = "select * from t_test"; List<Map<String, Object>> list = baseProjectDao.queryBySql(sql); printList(list); TestEntity testEntity = TestEntity.createInstance(); Serializable id = baseProjectDao.save(testEntity); String sqlByListParam = sql + " where id = ?0"; Object[] objects = {id}; List<Map<String, Object>> sqlByListParamList = baseProjectDao.queryBySql(sqlByListParam, objects); printList(sqlByListParamList); List<Map<String, Object>> sqlByListParamListPage = baseProjectDao.queryBySqlAndPage(sqlByListParam, 0, 5, objects); printList(sqlByListParamListPage); String sqlByListMap = sql + " where id = :id"; Map<String, Object> param = new HashMap<>(); param.put("id", id); List<Map<String, Object>> sqlByListMapList = baseProjectDao.queryBySql(sqlByListMap, param); printList(sqlByListMapList); List<Map<String, Object>> sqlByListMapListPage = baseProjectDao.queryBySqlAndPage(sqlByListMap, 0, 5, param); printList(sqlByListMapListPage); } @Test public void queryUniqueResultTest() { String sql = "select count(*) from t_test"; TestEntity testEntity = TestEntity.createInstance(); Serializable id = baseProjectDao.save(testEntity); Object count = baseProjectDao.queryUniqueResult(sql); logger.info(String.valueOf(count)); String sqlByListParam = sql + " where id = ?0"; Object countByListParam = baseProjectDao.queryUniqueResult(sqlByListParam, new Object[]{id}); logger.info(String.valueOf(countByListParam)); String sqlByListMap = sql + " where id = :id"; Map<String, Object> param = new HashMap<>(); param.put("id", id); Object countByMapCount = baseProjectDao.queryUniqueResult(sqlByListMap, param); logger.info(String.valueOf(countByMapCount)); } @Test public void executeHqlTest() { String hql = "delete TestEntity "; TestEntity testEntity = TestEntity.createInstance(); baseProjectDao.save(testEntity); Object count = baseProjectDao.executeHql(hql); logger.info(String.valueOf(count)); Serializable id = baseProjectDao.save(testEntity); String hqlByListParam = hql + " where id = ?0"; int countByList = baseProjectDao.executeHql(hqlByListParam, new Object[]{id}); logger.info(String.valueOf(countByList)); id = baseProjectDao.save(testEntity); String hqlByMapParam = hql + " where id = :id"; Map<String, Object> param = new HashMap<>(); param.put("id", id); int countByMap = baseProjectDao.executeHql(hqlByMapParam, param); logger.info(String.valueOf(countByMap)); } @Test public void executeSqlTest() { String sql = "delete from t_test "; TestEntity testEntity = TestEntity.createInstance(); baseProjectDao.save(testEntity); Object count = baseProjectDao.executeSql(sql); logger.info(String.valueOf(count)); Serializable id = baseProjectDao.save(testEntity); String hqlByListParam = sql + " where id = ?0"; int countByList = baseProjectDao.executeSql(hqlByListParam, new Object[]{id}); logger.info(String.valueOf(countByList)); id = baseProjectDao.save(testEntity); String hqlByMapParam = sql + " where id = :id"; Map<String, Object> param = new HashMap<>(); param.put("id", id); int countByMap = baseProjectDao.executeSql(hqlByMapParam, param); logger.info(String.valueOf(countByMap)); } }

2、测试service类TestServiceImplTest

package com.moy.moyapp.test.service.impl;

import com.moy.moyapp.test.entity.TestEntity;
import com.moy.moyapp.test.service.TestService;
import org.junit.After;
import org.junit.Before;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;

import javax.annotation.Resource;
import java.io.Serializable;
import java.util.HashMap;
import java.util.List;
import java.util.Map;


/**
 * [Project]:moy-gradle-project  <br/>
 * [Email]:[email protected]  <br/> * [Date]:2018/3/6 <br/> * [Description]: <br/> * * @author YeXiangYang */ @RunWith(SpringJUnit4ClassRunner.class) @ContextConfiguration("/spring.xml") public class TestServiceImplTest { @Resource TestService testService; Logger logger = LoggerFactory.getLogger(getClass()); long beforeTime; long afterTime; @Before public void before() { logger.info(this.toString()); beforeTime = System.currentTimeMillis(); logger.info("test method before : {}ms", beforeTime); } @After public void After() { afterTime = System.currentTimeMillis(); logger.info("test method After : {}ms", afterTime); logger.info("total time : {}ms", afterTime - beforeTime); } @Test public void saveTest() { TestEntity entity = TestEntity.createInstance(); logger.info(testService.save(entity).toString()); } @Test public void deleteTest() { TestEntity entity = TestEntity.createInstance(); Serializable id = testService.save(entity); logger.info(String.valueOf(testService.delete(id))); logger.info(String.valueOf(testService.save(entity))); testService.delete(entity); } @Test public void deleteByMapTest() { TestEntity entity = TestEntity.createInstance(); Serializable id = testService.save(entity); HashMap<String, Object> param = new HashMap<>(); param.put("id", id); logger.info(String.valueOf(testService.deleteByMap(param))); testService.save(entity); testService.delete(entity); id = testService.save(entity); testService.delete(id); } @Test public void updateTest() { TestEntity entity = TestEntity.createInstance(); testService.save(entity); entity.setDesc(null); testService.update(entity); } @Test public void saveOrUpdateTest() { TestEntity entity = TestEntity.createInstance(); testService.saveOrUpdate(entity); entity.setDesc(null); testService.saveOrUpdate(entity); } @Test public void getTest() { TestEntity entity = TestEntity.createInstance(); Serializable id = testService.save(entity); TestEntity testEntity = testService.get(id); logger.info(testEntity.toString()); } @Test public void listAllTest() { List<TestEntity> list = testService.listAll(); printList(list); } @Test public void listByMapTest() { TestEntity entity = TestEntity.createInstance(); testService.save(entity); Map<String, Object> param = new HashMap<>(); param.put("desc", entity.getDesc()); List<TestEntity> list = testService.listByMap(param); printList(list); } @Test public void countAllTest() { TestEntity entity = TestEntity.createInstance(); testService.save(entity); logger.info(String.valueOf(testService.countAll())); } @Test public void countByMapTest() { TestEntity entity = TestEntity.createInstance(); testService.save(entity); Map<String, Object> param = new HashMap<>(); param.put("id", entity.getId()); logger.info(String.valueOf(testService.countByMap(param))); } @Test public void saveTxTest() { try { testService.saveTxTest(); } catch (Exception e) { e.printStackTrace(); } } private void printList(List list) { if (null != list) { for (Object each : list) { logger.info(each.toString()); } } } }

3、运行tomcat7插件后，打开浏览器，输入127.0.0.1:8080/moyapp测试接口和事务接口。

Maven配置SpringMVC4+Spring4+Hibernate4环境

猜你喜欢