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]:moy25@foxmail.com <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]:moy25@foxmail.com <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]:moy25@foxmail.com <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]:moy25@foxmail.com <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]:moy25@foxmail.com <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]:moy25@foxmail.com <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]:moy25@foxmail.com <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]:moy25@foxmail.com <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]:moy25@foxmail.com <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]:moy25@foxmail.com <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]:moy25@foxmail.com <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测试接口和事务接口。
