SSH+MAVEN环境的搭建及测试

2019独角兽企业重金招聘Python工程师标准>>>

一.pom.xml

<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
  <modelVersion>4.0.0</modelVersion>
  <groupId>fll.test</groupId>
  <artifactId>Test</artifactId>
  <version>0.0.1-SNAPSHOT</version>
  <packaging>war</packaging>
  <name>SSHAxis2WebService</name>
  <build>
    <plugins>
      <plugin>
        <artifactId>maven-compiler-plugin</artifactId>
        <version>3.3</version>
        <configuration>
          <source>1.7</source>
          <target>1.7</target>
          <encoding>UTF-8</encoding>
          <compilerArguments>
                  <extdirs>src\main\webapp\WEB-INF\lib</extdirs>
          </compilerArguments>
        </configuration>
      </plugin>
      <plugin>
            <artifactId>maven-war-plugin</artifactId>
            <version>2.6</version>
            <configuration>
                <warSourceDirectory>src/main/webapp</warSourceDirectory>
                <failOnMissingWebXml>false</failOnMissingWebXml>
            </configuration>
      </plugin>
    </plugins>
  </build>
  
  <properties>
          <!-- spring的版本号 -->
          <spring-version>4.1.4.RELEASE</spring-version>
  </properties>
  <dependencies>
      <dependency>
          <groupId>junit</groupId>
          <artifactId>junit</artifactId>
          <version>3.8.2</version>
      </dependency>
      
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-core</artifactId>
        <version>${spring-version}</version>
    </dependency>
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-context</artifactId>
        <version>${spring-version}</version>
    </dependency>
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-jdbc</artifactId>
        <version>${spring-version}</version>
    </dependency>
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-beans</artifactId>
        <version>${spring-version}</version>
    </dependency>
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-web</artifactId>
        <version>${spring-version}</version>
    </dependency>
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-expression</artifactId>
        <version>${spring-version}</version>
    </dependency>
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-orm</artifactId>
        <version>${spring-version}</version>
    </dependency>
    
    <dependency>
              <groupId>junit</groupId>
              <artifactId>junit</artifactId>
              <version>4.12</version>
              <!-- 这里的test表示测试时编译src/test/java文件夹中的文件，等发布的时候不编译 -->
              <scope>test</scope>
          </dependency>
          
          <!-- struts2的核心包 -->
        <dependency>
            <groupId>org.apache.struts</groupId>
            <artifactId>struts2-core</artifactId>
            <version>2.3.16</version>
            <!-- 这里的exclusions是排除包，因为struts2中有javassist，Hibernate中也有javassist
            所以如果整合Hibernate，一定要排除struts2中的javassist，否则就冲突了 -->
            <exclusions>
                <exclusion>
                    <groupId>javassist</groupId>
                    <artifactId>javassist</artifactId>
                </exclusion>
            </exclusions>
        </dependency>
        <!-- convention-plugin插件，使用了这个插件之后，就可以采用注解的方法配置action -->
        <!-- <dependency>
            <groupId>org.apache.struts</groupId>
            <artifactId>struts2-convention-plugin</artifactId>
            <version>2.3.20</version>
        </dependency> -->
        <!-- struts2和spring整合插件 -->
        <dependency>
            <groupId>org.apache.struts</groupId>
            <artifactId>struts2-spring-plugin</artifactId>
            <version>2.3.4.1</version>
        </dependency>
        
        <!-- Hibernate4 -->
        <dependency>
            <groupId>org.hibernate</groupId>
            <artifactId>hibernate-core</artifactId>
            <version>4.2.5.Final</version>
        </dependency>
        
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>5.1.34</version>
        </dependency>
        <!-- SQLServer数据库驱动包 -->
        <dependency>
            <groupId>net.sourceforge.jtds</groupId>
            <artifactId>jtds</artifactId>
            <version>1.3.1</version>
        </dependency>
        <!-- oracle数据库驱动包 -->
        <dependency>
             <groupId>com.oracle</groupId>
            <artifactId>ojdbc7</artifactId>
            <version>12.1.0.1</version> 
            <groupId>com.hynnet</groupId>
            <artifactId>oracle-driver-ojdbc</artifactId>
            <version>12.1.0.2</version>
        </dependency>
        <!-- 添加Druid数据库连接池jar包 -->
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>druid</artifactId>
            <version>1.0.12</version>
        </dependency>
        <!-- 添加c3p0数据库连接池jar包 -->
        <dependency>
            <groupId>com.mchange</groupId>
            <artifactId>c3p0</artifactId>
            <version>0.9.5-pre8</version>
        </dependency>
        <!-- 添加dbcp数据库连接池jar包 -->
        <dependency>
            <groupId>commons-dbcp</groupId>
            <artifactId> commons-dbcp </artifactId>
            <version>1.4</version>
        </dependency>
        <!-- aspectjweaver包 AOP -->
        <!-- <dependency>
            <groupId>org.aspectj</groupId>
            <artifactId>aspectjweaver</artifactId>
            <version>1.8.5</version>
        </dependency> -->
  </dependencies>
</project>

----------------------------------------------------------------------------------------------------------------------------------------------

二.web.xml

<?xml version="1.0" encoding="UTF-8"?>
<web-app xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns="http://java.sun.com/xml/ns/javaee" xsi:schemaLocation="http://java.sun.com/xml/ns/javaee http://java.sun.com/xml/ns/javaee/web-app_3_0.xsd" id="WebApp_ID" version="3.0">
  <display-name>SSHAxis2WebService</display-name>
  <!-- Spring监听器 -->
  <listener>
    <listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
  </listener>
  <!-- Spring配置文件位置 -->
  <context-param>
      <param-name>contextConfigLocation</param-name>
      <param-value>classpath:spring.xml</param-value>
  </context-param>
  <!-- 防止spring内存溢出监听器 -->
  <listener>
    <listener-class>org.springframework.web.util.IntrospectorCleanupListener</listener-class>
  </listener>
  <!-- openSessionInView配置 -->
  <filter>
      <filter-name>openSessionInViewFilter</filter-name>
    <filter-class>org.springframework.orm.hibernate4.support.OpenSessionInViewFilter</filter-class>
     <init-param>
         <param-name>singleSession</param-name>
         <param-value>true</param-value>
     </init-param>
  </filter>
  <filter-mapping>
      <filter-name>openSessionInViewFilter</filter-name>
      <url-pattern>*.action</url-pattern>
  </filter-mapping>

  <!-- struts2的核心过滤器配置 -->
  <filter>
      <filter-name>struts2</filter-name>
    <filter-class>org.apache.struts2.dispatcher.ng.filter.StrutsPrepareAndExecuteFilter</filter-class>
  </filter>
  <!-- struts2过滤器拦截所有的.action请求 -->
  <filter-mapping>
      <filter-name>struts2</filter-name>
      <url-pattern>*.action</url-pattern>
  </filter-mapping>
  
  <!-- druid监控页面，使用${pageContext.request.contextPath}/druid/index.html访问 -->
  <servlet>
      <servlet-name>druidStatView</servlet-name>
      <servlet-class>com.alibaba.druid.support.http.StatViewServlet</servlet-class>
  </servlet>
  <servlet-mapping>
      <servlet-name>druidStatView</servlet-name>
      <url-pattern>/druid/*</url-pattern>
  </servlet-mapping>
  
  <welcome-file-list>
      <welcome-file>index.jsp</welcome-file>
  </welcome-file-list>
</web-app>

---------------------------------------------------------------------------------------------------------------------------------------------

三.配置文件

1.config.properties(数据库联接配置)

hibernate.dialect = org.hibernate.dialect.OracleDialect
driverClassName = oracle.jdbc.driver.OracleDriver
validationQuery = SELECT 1 FROM DUAL
jdbc_url = jdbc:oracle:thin:@10.0.0.173:1521:orcl
#jdbc:oracle.thin:@//127.0.0.1:1521/dbname
jdbc_username = tpkj
jdbc_password = tpkj

#hibernate.dialect = org.hibernate.dialect.MySQLDialect
#driverClassName = com.mysql.jdbc.Driver
#validationQuery = SELECT 1
#jdbc_url = jdbc:mysql://localhost:3306/ssh
#jdbc_username = root
#jdbc_password = 12345

#hibernate.dialect = org.hibernate.dialect.SQLServerDialect
#driverClassName = net.sourceforge.jtds.jdbc.Driver
#validationQuery = SELECT 1
#jdbc_url = jdbc:jtds:sqlserver://127.0.0.1:1433/dbname
#jdbc_username = sa
#jdbc_password = 123456

hibernate.hbm2ddl.auto = update
hibernate.show_sql = true
hibernate.format_sql = true

2.spring.xml

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:context="http://www.springframework.org/schema/context"
    xmlns:tx="http://www.springframework.org/schema/tx" xmlns:aop="http://www.springframework.org/schema/aop"
    xsi:schemaLocation="http://www.springframework.org/schema/beans
               http://www.springframework.org/schema/beans/spring-beans-4.0.xsd
               http://www.springframework.org/schema/context
               http://www.springframework.org/schema/context/spring-context-4.0.xsd
               http://www.springframework.org/schema/tx
               http://www.springframework.org/schema/tx/spring-tx-4.0.xsd
               http://www.springframework.org/schema/aop
               http://www.springframework.org/schema/aop/spring-aop-4.0.xsd ">
     
     <!-- 引入spring-hibernate.xml文件 -->    
     <import resource="spring-hibernate.xml"/>

    <!-- 引入属性文件,config.properties位于src/main/resources目录下   -->
    <context:property-placeholder location="classpath:config.properties"/>
    
     <!-- 自动扫描dao和service包(自动注入) -->
    <context:component-scan base-package="com.youms.ssh.webService" />  
</beans>

3.spring-hibernate.xml

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:context="http://www.springframework.org/schema/context"
    xmlns:tx="http://www.springframework.org/schema/tx" xmlns:aop="http://www.springframework.org/schema/aop"
    xsi:schemaLocation="http://www.springframework.org/schema/beans
               http://www.springframework.org/schema/beans/spring-beans-4.0.xsd
               http://www.springframework.org/schema/context
               http://www.springframework.org/schema/context/spring-context-4.0.xsd
               http://www.springframework.org/schema/tx
               http://www.springframework.org/schema/tx/spring-tx-4.0.xsd
               http://www.springframework.org/schema/aop
               http://www.springframework.org/schema/aop/spring-aop-4.0.xsd
               ">
    <!-- 配置druid数据源 -->
    <bean name="dataSource" class="com.alibaba.druid.pool.DruidDataSource" init-method="init" destroy-method="close">
        <property name="url" value="${jdbc_url}"/>
        <property name="username" value="${jdbc_username}"/>
        <property name="password" value="${jdbc_password}"/>
        <!-- 初始化连接大小 -->
        <property name="initialSize" value="0" />
        <!-- 连接池最大使用连接数量 -->
        <property name="maxActive" value="20"/>
        <!-- 连接池最大空闲 -->
        <property name="maxIdle" value="20"/>
        <!-- 连接池最小空闲 -->
        <property name="minIdle" value="0"/>
        <!-- 获取最大等待时间 -->
        <property name="maxWait" value="60000"/>
        <property name="poolPreparedStatements" value="false" /> 
        <property name="validationQuery" value="${validationQuery}"/>
        <property name="testOnBorrow" value="false"/>
        <property name="testOnReturn" value="false"/>
        <property name="testWhileIdle" value="true"/>
        <!-- 配置间隔多久才进行一次检测，检测需要关闭的空闲连接，单位是毫秒 -->
        <property name="timeBetweenEvictionRunsMillis" value="60000"/>
        <!-- 配置一个连接在池中最小生存的时间，单位是毫秒 -->
        <property name="minEvictableIdleTimeMillis" value="25200000"/>
        <!-- 打开removeAbandoned功能 -->
        <property name="removeAbandoned" value="true"/>
        <!-- 1800秒，也就是30分钟 -->
        <property name="removeAbandonedTimeout" value="1800"/>
        <!-- 关闭abanded连接时输出错误日志 -->
        <property name="logAbandoned" value="true"/>
        <!-- 监控数据库 -->
        <property name="filters" value="mergeStat"/>
    </bean>
    
    <!-- 配置hibenrate session工厂 -->
    <bean id="sessionFactory" class="org.springframework.orm.hibernate4.LocalSessionFactoryBean">
        <property name="dataSource" ref="dataSource"/>
        <property name="hibernateProperties">
            <props>
                <!-- web项目启动时是否更新表结构 -->
                <prop key="hibernate.hbm2ddl.auto">${hibernate.hbm2ddl.auto}</prop>
                <!-- 系统使用的数据库方言，也就是使用的数据库类型 -->
                <prop key="hibernate.dialect">${hibernate.dialect}</prop>
                <!-- 是否打印Hibernate生成的SQL到控制台 -->
                <!-- <prop key="hibernate.show_sql">${hibernate.show_sql}</prop> -->
                <!-- 是否格式化打印出来的SQL -->
                <prop key="hibernate.format_sql">${hibernate.format_sql}</prop>
                <!-- 是否使用注释  -->  
                <!-- <prop key="use_sql_comments">true</prop> --> 
            </props>
        </property>
        <!-- 自动扫描注解方式配置的hibernate实体类文件 -->
        <property name="packagesToScan">
            <list>
                <value>com.youms.ssh.webService.entity</value>
            </list>
        </property>
        <!-- 自动扫描hbm方式配置的hibernate文件和.hbm文件 -->
        <!-- <property name="mappingDirectoryLocations">
            <list>
                <value>classpath:com/youms/ssh/webService/entity/hbm</value>
            </list>
        </property>-->
    </bean>
    
    <!-- 配置事物管理器 -->
    <bean name="transactionManager" class="org.springframework.orm.hibernate4.HibernateTransactionManager">
        <property name="sessionFactory" ref="sessionFactory"></property>
    </bean>
    <!-- 注解方式配置事物 -->
    <!-- <tx:annotation-driven transaction-manager="transactionManager"/> -->
    <!-- 拦截器方式配置事物 -->
    <tx:advice id="transactionAdvice" transaction-manager="transactionManager">
        <tx:attributes>
            <!-- 以如下关键字开头的方法使用事物 -->
            <tx:method name="add*"/>
            <tx:method name="save*"/>
            <tx:method name="update*"/>
            <tx:method name="modify*"/>
            <tx:method name="edit*"/>
            <tx:method name="delete*"/>
            <tx:method name="remove*"/>
            <tx:method name="repair*"/>
            <tx:method name="deleteAndRepair"/>
            <!-- 以如下关键字开头的方法不使用事物 -->
            <tx:method name="get*" propagation="SUPPORTS"/>
            <tx:method name="find*" propagation="SUPPORTS"/>
            <tx:method name="load*" propagation="SUPPORTS"/>
            <tx:method name="search*" propagation="SUPPORTS"/>
            <tx:method name="datagrid*" propagation="SUPPORTS"/>
            <!-- 其它方法不使用事物 -->
            <tx:method name="*" propagation="SUPPORTS"/>
        </tx:attributes>
    </tx:advice>
    
    <!-- 切面，将事物用在哪些对象上 -->
    <aop:config>
        <aop:pointcut expression="execution(* com.youms.ssh.webService.service..*Impl.*(..))" id="transactionPointcut"/>
        <aop:advisor pointcut-ref="transactionPointcut" advice-ref="transactionAdvice"/>
    </aop:config>
</beans>

4.struts.xml

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE struts PUBLIC "-//Apache Software Foundation//DTD Struts Configuration 2.3//EN" "http://struts.apache.org/dtds/struts-2.3.dtd">
<struts>
    <!-- 指定spring负责action对象的创建 -->
    <constant name="struts.objectFactory" value="spring" />
    <!-- (所有匹配*.action的请求都由struts2处理)指定被struts2处理的请求后缀类型，多个用逗号隔开 -->
    <constant name="struts.action.extension" value="action,do" />
    <!-- 是否启用开发模式(开发时设置为true,发布到生成环境后设置为false) -->
    <constant name="struts.devMode" value="true" />
    <!-- struts配置文件改动后，是否重新加载(开发时设置为true,发布到生产环境后设置为false) -->
    <constant name="struts.configuration.xml.reload" value="true" />
    <!-- 设置浏览器是否缓存静态内容(开发时设置为false，发布到生产环境后设置为true) -->
    <constant name="struts.serve.static.browserCache" value="false" />
    <!-- 请求参数的编码方式 -->
    <constant name="struts.i18n.encoding" value="utf-8" />
    <!-- 每次HTTP请求系统都重新加载资源文件，有助于开发(开发设置为true,发布到生成环境设置为false) -->
    <constant name="struts.i18n.reload" value="true" />
    <!-- 文件上传的最大值(字节)，这里为10M -->
    <constant name="struts.multipart.maxSize" value="10485760" />
    <!-- 让struts2支持动态方法调用，使用叹号访问方法 -->
    <constant name="struts.enable.DynamicMethodInvocation" value="true" />
    <!-- action名称中是否还是用斜线 -->
    <constant name="struts.enable.SlashesInActionNames" value="false" />
    <!-- 允许标签中使用表达式语法 -->
    <constant name="struts.tag.altSyntax" value="true" />
    <!-- 对于WebLogic,Orion,OC4J此属性应该设置为true -->
    <constant name="struts.dispatcher.parametersWorkaround" value="false" />
    
    <include file="struts2.xml"/>
</struts>

5.struts2.xml

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE struts PUBLIC "-//Apache Software Foundation//DTD Struts Configuration 2.3//EN" "http://struts.apache.org/dtds/struts-2.3.dtd">
<struts>
    <package name="basePackage" namespace="/" extends="struts-default" >
        <!-- struts2的拦截器，调用顺序是先params后prepare在params -->
        <default-interceptor-ref name="paramsPrepareParamsStack"/>
        <action name="testAction" class="com.youms.ssh.webService.action.TestAction" method="test">
        </action>
        <action name="userAction" class="com.youms.ssh.webService.action.TestAction" method="saveUser">
        </action>
    </package>
</struts>

------------------------------------------------------------------------------------------------------------------------------------------

四.java

1.实体

package com.youms.ssh.webService.entity;
// Generated 2016-7-28 18:53:30 by Hibernate Tools 4.3.1.Final

import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;
import javax.persistence.Table;

/**
 * SshUser generated by hbm2java
 */
@Entity
//@Table(name = "ssh_user", catalog = "ssh") catalog:数据库，mysql时使用
@Table(name = "ssh_user")
public class SshUser implements java.io.Serializable {

    /**
     * 
     */
    private static final long serialVersionUID = 1L;
    
    private Integer id;
    private String userName;
    private String loginName;
    private String loginPassword;

    public SshUser() {
    }

    public SshUser(Integer id, String userName, String loginName, String loginPassword) {
        this.id = id;
        this.userName = userName;
        this.loginName = loginName;
        this.loginPassword = loginPassword;
    }
    @Id
    //@GeneratedValue(strategy = GenerationType.IDENTITY)主键数值自动生成
    @Column(name = "ID", unique = true, nullable = false)
    public Integer getId() {
        return this.id;
    }

    public void setId(Integer id) {
        this.id = id;
    }
    @Column(name = "user_name", nullable = false, length = 50)
    public String getUserName() {
        return this.userName;
    }

    public void setUserName(String userName) {
        this.userName = userName;
    }

    @Column(name = "login_name", nullable = false, length = 50)
    public String getLoginName() {
        return this.loginName;
    }

    public void setLoginName(String loginName) {
        this.loginName = loginName;
    }

    @Column(name = "login_password", nullable = false, length = 32)
    public String getLoginPassword() {
        return this.loginPassword;
    }

    public void setLoginPassword(String loginPassword) {
        this.loginPassword = loginPassword;
    }

    @Override
    public String toString() {
        return "SshUser [id=" + id + ", userName=" + userName + ", loginName=" + loginName + ", loginPassword="
                + loginPassword + "]";
    }

}

2.通用dao

package com.youms.ssh.webService.Dao;

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

import org.hibernate.Query;
import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.hibernate.criterion.Restrictions;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Qualifier;
/**
 * 统一的增、删、改、查等方法
 * @author youmusen
 * @date 2016/02/25 16:58
 *
 * @param <T>
 * @param <PK>
 */
public class BaseDaoSupport<T,PK extends java.io.Serializable> {
    protected final Class<T> entityClass;
    protected String className;
    
    @Autowired
    @Qualifier("sessionFactory")
    private SessionFactory sessionFactory;
    
    @SuppressWarnings("unchecked")
    public BaseDaoSupport(){
        this.entityClass = (Class<T>)((ParameterizedType)getClass().getGenericSuperclass()).getActualTypeArguments()[0];
        this.className = this.entityClass.getSimpleName();
    }
    
    //获取session
    public Session getCurSession(){
        return this.sessionFactory.getCurrentSession();
    }
    
    //保存
    public Serializable save(T entity){
        return this.getCurSession().save(entity);
    }
    
    //根据id，查找对应的实体
    @SuppressWarnings("unchecked")
    public T get(final PK id){
        return (T)this.getCurSession().get(this.entityClass, id);
    }
    //查找所有的数据
    @SuppressWarnings("unchecked")
    public List<T> findAll(){
        Session session = this.getCurSession();
        List<T> result = session.createCriteria(this.entityClass).list();
        
        return result;
    }
    
    //根据property查找对应的数据
    @SuppressWarnings("unchecked")
    public List<T> findByProperty(String property,Object value){
        return this.getCurSession().createCriteria(this.entityClass)
                .add(Restrictions.eq(property, value)).list();
    }
    
    //更新数据
    public void update(Object obj){
        this.getCurSession().update(obj);
    }
    
    //根据id删除相应的实体
    public void delete(final PK id){
        this.getCurSession().delete(get(id));
    }
    
    //删除相应的数据
    public void delete(Object obj){
        this.getCurSession().delete(obj);
    }
    
    //自定义无参sql
    @SuppressWarnings("unchecked")
    public List<T> MyHql(String hql){
        return this.getCurSession().createSQLQuery(hql).addEntity(this.entityClass).list();
    };
    
    //自定义sql
    @SuppressWarnings("unchecked")
    public List<T> query(String sql, List<Object> condition){
        Query query = this.getCurSession().createSQLQuery(sql).addEntity(this.entityClass);
        if (condition != null && condition.size() > 0) {
            for (int i = 0; i < condition.size(); i++) {
                query.setParameter(i, condition.get(i));
            }
        }
        return query.list();
    }
}
 

3.dao

package com.youms.ssh.webService.Dao;

import org.springframework.stereotype.Repository;
import com.youms.ssh.webService.entity.SshUser;
/**
 * 
 * @description SshUser实体类的接口类，该类继承了BaseDaoSupport中所有的方法
 * @author youmusen
 * @date 2016年7月28日下午7:31:03
 */
//使用@Repository("userDao")注解完成dao注入
@Repository("userDao")
public class UserDao extends BaseDaoSupport<SshUser, Integer> {

}
 

4.service

package com.youms.ssh.webService.service;

import java.util.List;

import com.youms.ssh.webService.entity.SshUser;

/**
 * 
 * @description 测试接口
 * @author youmusen
 * @date 2016年7月27日下午6:50:07
 */
public interface UserService {
    /**
     * 
     * @description 测试方法
     * @author youmusen
     * @date 2016年7月27日下午6:50:27
     */
    public void test();
    
    /**
     * @description 保存用户
     * @author youmusen
     * @date 2016年7月28日下午7:36:43
     * @param suser 实体类SshUser
     */
    public void save(SshUser suser);
    
    /**
     * 返回多个实体对象
     * @param property
     * @param value
     * @return
     */
    public List<SshUser> getListEntity(String property,Object value);
    
    /**
     * 自定义无参hql
     */
    public List<SshUser> MyHql(String hql);
    
    /**
     * 自定义sql
     * @return
     */
    public List<SshUser> MyTestSql(String sql,List<Object> condition);
    
    /**
     * 根据id查询实体
     * @param id
     */
    public void deleteById(Integer id);
}

5.service实现类

package com.youms.ssh.webService.service.impl;

import java.util.List;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import com.youms.ssh.webService.Dao.UserDao;
import com.youms.ssh.webService.entity.SshUser;
import com.youms.ssh.webService.service.UserService;

//使用Spring提供的@Service注解将UserServiceImpl标注为一个Service
@Service("userService")
public class UserServiceImpl implements UserService {
    
    //注入userDao
    @Autowired
    private UserDao userDao;

    @Override
    public void test() {
        // TODO Auto-generated method stub
        System.out.println("Hello SSH!");
    }
    
    @Override
    public void save(SshUser suser) {
        // TODO Auto-generated method stub
        this.userDao.save(suser);
    }

    @Override
    public List<SshUser> getListEntity(String property, Object value) {
        // TODO Auto-generated method stub
        return this.userDao.findByProperty(property, value);
    }
    
    @Override
    public List<SshUser> MyHql(String hql) {
        // TODO Auto-generated method stub
        return this.userDao.MyHql(hql);
    }

    @Override
    public List<SshUser> MyTestSql(String sql, List<Object> condition) {
        // TODO Auto-generated method stub
        return this.userDao.query(sql, condition);
    }

    @Override
    public void deleteById(Integer id) {
        // TODO Auto-generated method stub
        this.userDao.delete(id);
    }
}

6.测试类

package com.youms.ssh.webService.test;
import java.util.ArrayList;
import java.util.List;

import org.junit.After;
import org.junit.Before;
import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
import com.youms.ssh.webService.entity.SshUser;
import com.youms.ssh.webService.service.UserService;
public class HibernateTest {
    private UserService userService;
    
    /**
     * 
     * @description 这个setUp方法在所有的测试方法之前，并且只执行一次
     * 所有做Junit单元测试时一些初始化工作可以在这个方法里面进行
     * 比如在setUp方法里面初始化ApplicationContext和userService
     * @author youmusen
     * @date 2016年7月28日下午7:52:19
     * @throws Exception
     */
    @Before
    public void setUp() throws Exception {
        ApplicationContext ac = new ClassPathXmlApplicationContext(new String[]{"spring.xml","spring-hibernate.xml"});
        userService = (UserService)ac.getBean("userService");
    }

    @After
    public void tearDown() throws Exception {
    }

    @Test
    public void test() {
        SshUser suser = new SshUser();
        suser.setId(1);
        suser.setUserName("test");
        suser.setLoginName("test");
        suser.setLoginPassword("12345");
        
        this.userService.save(suser);
    }
    
    @Test
    //根据属性查询
    public void test3(){
        List<SshUser> list = this.userService.getListEntity("id", 1);
        System.out.println(list.get(0).getUserName());
    }
    
    @Test
    //自定义无参hql
    public void test4(){
        String hql = "SELECT * FROM ssh_user WHERE id = 2 ";
        List<SshUser> list = this.userService.MyHql(hql);
        System.out.println(list.get(0).getLoginName());
    }
    
    @Test
    //自定义sql
    public void test2(){
        String sql = "SELECT * FROM ssh_user "
                    + "WHERE ID = ?";
        List<Object> params = new ArrayList<Object>();
        params.add(2);
        List<SshUser> list = this.userService.MyTestSql(sql, params);
        System.out.println(list);
    }
    
    @Test//测试删除
    public void test5(){
        Integer id = 1;
        this.userService.deleteById(id);
    }
}

转载于:https://my.oschina.net/langgege/blog/736628