使用Maven搭建Struts2+Spring3+Hibernate4的整合开发环境_maven struts2 spring hibernate整合-程序员宅基地

技术标签： 框架整合  java Web  

使用Maven搭建Struts2+Spring3+Hibernate4的整合开发环境

一.新建Maven项目

1.新建一个Web Project

创建好的项目如下图所示：

2.修改默认的JDK
右键点击，选择Properties


3.创建Maven标准目录
　　　　src/main/java 
　　　　src/main/resources
　　　　src/test/java 
　　　　src/test/resources

4.发布项目：Maven install


OK，Maven工程创建成功！

二.搭建struts2开发环境

1.下载Struts2需要的jar包

　　1.strtus2-core 
　　2.struts2-convention-plugin(使用了这个插件之后，就可以采用注解的方式配置Struts的Action，免去了在struts.xml中的繁琐配置项)

　　3.struts2-config-browser-plugin(config-browser-plugin插件不是必须的，但是使用了这个插件之后，就可以很方便的浏览项目中的所有action及其与 jsp view的映射)

　　在pom.xml文件中编写Struts2所需要的jar包，Maven会自动下载这些包

        <!-- Struts2的核心包 -->
        <dependency>
            <groupId>org.apache.struts</groupId>
            <artifactId>struts2-core</artifactId>
            <version>2.3.16</version>
        </dependency>
        <!-- convention-plugin插件，使用了这个插件之后，就可以采用注解的方式配置Action -->
        <dependency>
            <groupId>org.apache.struts</groupId>
            <artifactId>struts2-convention-plugin</artifactId>
            <version>2.3.20</version>
        </dependency>
        <!--config-browser-plugin插件，使用了这个插件之后，就可以很方便的浏览项目中的所有action及其与 jsp view的映射 -->
        <dependency>
            <groupId>org.apache.struts</groupId>
            <artifactId>struts2-config-browser-plugin</artifactId>
            <version>2.3.20</version>
        </dependency>

2.编写struts.xml配置文件

在src/main/resources目录下创建一个struts.xml文件，如下图所示：


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>

    <!-- 所有匹配*.action的请求都由struts2处理 -->
    <constant name="struts.action.extension" value="action" />
    <!-- 是否启用开发模式(开发时设置为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" />
    <!-- 文件上传最大值 -->
    <constant name="struts.multipart.maxSize" value="104857600" />
    <!-- 让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" />

    <package name="basePackage" extends="struts-default">


    </package>

</struts>


3.在web.xml中配置Struts2的过滤器

<?xml version="1.0" encoding="UTF-8"?>
<web-app version="3.0" 
	xmlns="http://java.sun.com/xml/ns/javaee" 
	xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" 
	xsi:schemaLocation="http://java.sun.com/xml/ns/javaee 
	http://java.sun.com/xml/ns/javaee/web-app_3_0.xsd">
  <display-name></display-name>	
  <welcome-file-list>
    <welcome-file>index.jsp</welcome-file>
  </welcome-file-list>
    <!-- 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>
</web-app>


4.编写测试action

首先，在src/main/java中创建com.cosconset.action包，在包中编写一个 TestAction类，如下图所示：


代码如下： 
package com.cosconet.action;

import org.apache.struts2.convention.annotation.Action;
import org.apache.struts2.convention.annotation.Namespace;
import org.apache.struts2.convention.annotation.ParentPackage;
import org.apache.struts2.convention.annotation.Result;
import org.apache.struts2.convention.annotation.Results;

@ParentPackage("basePackage")
@Action(value="strust2Test")//使用convention-plugin插件提供的@Action注解将一个普通java类标注为一个可以处理用户请求的Action，Action的名字为struts2Test
@Namespace("/")//使用convention-plugin插件提供的@Namespace注解为这个Action指定一个命名空间
@Results( { @Result(name = "success", location = "/success.jsp"),
	@Result(name = "input", location = "/register.jsp") })
public class TestAction {
    

    /**
     * http://localhost:8080/SSHE/strust2Test!test.action
     * MethodName: test
     * Description: 
     * @author xudp
     */
    public String test(){
        System.out.println("进入TestAction");
        return "success";
    }
}

测试Struts2的开发环境是否搭建成功，先执行【Maven install】操作,然后部署到tomcat服务器，最后启动tomcat服务器运行,输入访问地址：http://localhost:8080/SSHE/strust2Test!test.action，访问结果如下：



测试通过，Struts2的开发环境搭建成功!

二.搭建spring3开发环境

1.下载spring3的jar包

　　　　1.spring-core

　　　　2.spring-context

　　　　3.spring-jdbc

　　　　4.spring-beans

　　　　5.spring-web

　　　　6.spring-expression

　　　　7.spring-orm

　　在pom.xml中编写Spring3需要的包，maven会自动下载这些包以及相关的依赖jar包。

        <!-- spring3 -->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-core</artifactId>
            <version>3.1.2.RELEASE</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context</artifactId>
            <version>3.1.2.RELEASE</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-jdbc</artifactId>
            <version>3.1.2.RELEASE</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-beans</artifactId>
            <version>3.1.2.RELEASE</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-web</artifactId>
            <version>3.1.2.RELEASE</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-expression</artifactId>
            <version>3.1.2.RELEASE</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-orm</artifactId>
            <version>3.1.2.RELEASE</version>
        </dependency>
 <span style="white-space:pre">		</span><!--aspectjweaver包 -->
        <dependency>
            <groupId>org.aspectj</groupId>
            <artifactId>aspectjweaver</artifactId>
            <version>1.8.5</version>
        </dependency>
2.编写spring配置文件
在src/main/resources目录下创建一个spring.xml文件，如下图所示：

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" 
xsi:schemaLocation="http://www.springframework.org/schema/beans 
http://www.springframework.org/schema/beans/spring-beans-3.0.xsd 
http://www.springframework.org/schema/context 
http://www.springframework.org/schema/context/spring-context-3.0.xsd
">

    <!-- 引入属性文件,config.properties位于src/main/resources目录下 -->
    <context:property-placeholder location="classpath:config.properties" />

    <!-- 自动扫描dao和service包(自动注入) -->
    <context:component-scan base-package="com.cosconet.dao,com.cosconet.service" />

</beans>
在src/main/resources目录下创建一个config.properties文件，如下图所示：

config.properties文件主要是用来编写一些系统的配置信息，例如数据库连接信息，config.properties文件中的内容暂时先不编写，等整合到Hibernate时再编写具体的数据库连接信息。
3.编写单元测试
首先，在src/main/java中创建com.cosconet.service包，在包中编写一个 UserServiceI 接口，如下图所示：

代码如下： 
package com.cosconet.service;

public interface UserServiceI {

    /**
     * 测试方法
     */
    void test();
}
然后，在src/main/java中创建com.cosconet.service.impl包，在包中编写UserServiceImpl实现类，如下图所示：

代码如下： 
package com.cosconet.service.impl;

import org.springframework.stereotype.Service;
import com.cosconet.service.UserServiceI;

//使用Spring提供的@Service注解将UserServiceImpl标注为一个Service
@Service("userService")
public class UserServiceImpl implements UserServiceI {

  @Override
  public void test() {
      System.out.println("Hello World!");
  }

}
进行单元测试时需要使用到Junit，所以需要在pom.xml文件中添加Junit的jar包描述，如下： 
<span style="white-space:pre">	</span><!-- Junit -->
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.12</version>
            <scope>test</scope>
        </dependency>
<scope>test</scope> 这里的test表示测试时编译src/main/test文件夹中的文件，等发布的时候不编译。
最后，在src/main/test中创建com.cosconet.test包，在包中编写 TestSpring类，如下图所示：
代码如下： 
package com.cosconet.test;

import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

import com.cosconet.service.UserServiceI;

public class TestSpring {
	
    @Test
    public void test(){
        //通过spring.xml配置文件创建Spring的应用程序上下文环境
        ApplicationContext ac = new ClassPathXmlApplicationContext("classpath:spring.xml");
        //从Spring的IOC容器中获取bean对象
        UserServiceI userService = (UserServiceI) ac.getBean("userService");
        //执行测试方法
        userService.test();
    }
}
JUnit Test运行，结果如图所示：


在tomcat服务器中进行测试，先执行【Maven install】命令发布项目,然后将COSCONET项目部署到tomcat服务器，最后启动tomcat服务器
tomcat服务器启动的过程中没有出现报错，输入地址：http://localhost:8080/COSCONET/ 能够正常进行访问，就说明Spring3的开发环境搭建成功，如下图所示：

测试通过，Spring3开发环境搭建成功！

三.搭建hibernate4开发环境

1.下载hibernate4的jar包

　　1.hibernate-core

　　在pom.xml文件中编写Hibernate4所需要的jar包，Maven会自动下载这些包。

 	<!-- hibernate4 -->
        <dependency>
            <groupId>org.hibernate</groupId>
            <artifactId>hibernate-core</artifactId>
            <version>4.1.7.Final</version>
            <!--
           	 这里的 exclusions 是排除包，因为 Struts2中有javassist，Hibernate中也有javassist,
           	 所以如果要整合Hibernate，一定要排除掉Struts2中的javassist，否则就冲突了。-->
            <exclusions>
                <exclusion>
                    <groupId>javassist</groupId>
                    <artifactId>javassist</artifactId>
                </exclusion>
            </exclusions> 
        </dependency>
2.添加数据库驱动jar包
我们知道，Hibernate是用于和数据库交互的，应用系统所有的CRUD操作都要通过Hibernate来完成。既然要连接数据库，那么就要使用到相关的数据库驱动，所以需要加入数据库驱动的jar包，根据自身项目使用的数据库在pom.xml文件中编写相应的数据库驱动jar：
MySQL数据库驱动jar： 
         <!-- mysql驱动包 -->
         <dependency>
             <groupId>mysql</groupId>
             <artifactId>mysql-connector-java</artifactId>
             <version>5.1.34</version>
         </dependency>
SQLServer数据库驱动jar:
因Maven找不到SQLServer的数据库驱动，所以要自己下载驱动，再添加到本地仓库。

Step 1

　　本次下载了4.0版本

Step 2

　　通过maven命令将jar包安装到本地。

　　在有sqljdbc4.jar包的文件夹下，通过shift+右键的方式--》此处打开命令窗口，然后执行以下maven命令

　　　　mvn install:install-file -Dfile=sqljdbc4.jar -Dpackaging=jar -DgroupId=com.microsoft.sqlserver -DartifactId=sqljdbc4 -Dversion=4.0　　

　　命令解释：mvn install:install-file -Dfile="jar包的绝对路径" -Dpackaging="文件打包方式" -DgroupId=groupid名 -DartifactId=artifactId名 -Dversion=jar版本 

Step 3

　　在pom.xml中引入本地jar包

<!--sqlserver驱动包 -->  
<dependency>  
    <groupId>com.microsoft.sqlserver</groupId>  
    <artifactId>sqljdbc4</artifactId>  
    <version>4.0</version>  
</dependency>  
<dependency>  
    <groupId>commons-dbcp</groupId>  
    <artifactId>commons-dbcp</artifactId>  
    <version>1.4</version>  
</dependency>
同样，Oracle数据库驱动jar包也要自己下载添加，方法同上，添加到本地仓库后， 在pom.xml中引入本地jar包 
 <span style="white-space:pre">	</span><!--Oracle数据库驱动包，针对Oracle11.2的ojdbc6.jar -->
         <dependency>  
              <groupId>com.oracle</groupId>  
              <artifactId>ojdbc6</artifactId>  
              <version>11.2.0.1.0</version>  
         </dependency>
3. 在src/main/resources目录下创建一个hibernate.cfg.xml文件，如下图所示：

在hibernate.cfg.xml编写数据库连接信息： 
<?xml version='1.0' encoding='utf-8'?>
<!DOCTYPE hibernate-configuration PUBLIC
        "-//Hibernate/Hibernate Configuration DTD 3.0//EN"
        "http://hibernate.sourceforge.net/hibernate-configuration-3.0.dtd">

<hibernate-configuration>
	<session-factory>

		<!-- Database connection settings -->
		<property name="connection.driver_class">com.microsoft.sqlserver.jdbc.SQLServerDriver</property>
		<property name="connection.url">jdbc:sqlserver://172.25.6.146:1433;DatabaseName=xsjdd;SelectMethod=cursor;</property>
		<property name="connection.username">sa</property>
		<property name="connection.password">cosnet</property>

		<!-- SQL dialect -->
		<property name="dialect">org.hibernate.dialect.SQLServerDialect</property>
		<!--
			将Session扔到线程里去处理，Enable Hibernate's automatic session context
			management
		-->
		<property name="current_session_context_class">thread</property>

		<!-- 在控制台打印SQL语句 -->
		<property name="show_sql">true</property>

		<!-- 自动把实体类与属性映射成数据库中的表与列 -->
		<property name="hbm2ddl.auto">update</property>

		<!--
			<mapping resource="cn/com/entity/User.hbm.xml"/>
		-->
		<!-- 在Hibernate中注册User实体类,区别于上面注释掉的resource写法 -->
		<mapping class="com.cosconet.model.User" />

	</session-factory>
</hibernate-configuration>
4.测试hibernate
在src/main/java中创建com.cosconet.model包，在包中编写实体User类，如下图所示：

代码如下： 
package com.cosconet.model;

import java.util.Date;

import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.Id;
import javax.persistence.Table;
import javax.persistence.Temporal;
import javax.persistence.TemporalType;

@Entity
@Table(name = "BD_TestUser", schema = "dbo")
public class User implements java.io.Serializable {

    // Fields
    private String id;
    private String name;
    private String pwd;
    private Date createdatetime;
    private Date modifydatetime;

    // Constructors

    /** default constructor */
    public User() {
    }

    /** minimal constructor */
    public User(String id, String name, String pwd) {
        this.id = id;
        this.name = name;
        this.pwd = pwd;
    }

    /** full constructor */
    public User(String id, String name, String pwd, Date createdatetime, Date modifydatetime) {
        this.id = id;
        this.name = name;
        this.pwd = pwd;
        this.createdatetime = createdatetime;
        this.modifydatetime = modifydatetime;
    }

    // Property accessors
    @Id
    @Column(name = "ID", unique = true, nullable = false, length = 36)
    public String getId() {
        return this.id;
    }

    public void setId(String id) {
        this.id = id;
    }

    @Column(name = "NAME",nullable = false, length = 100)
    public String getName() {
        return this.name;
    }

    public void setName(String name) {
        this.name = name;
    }

    @Column(name = "PWD", nullable = false, length = 32)
    public String getPwd() {
        return this.pwd;
    }

    public void setPwd(String pwd) {
        this.pwd = pwd;
    }

    @Temporal(TemporalType.TIMESTAMP)
    @Column(name = "CREATEDATETIME", length = 7)
    public Date getCreatedatetime() {
        return this.createdatetime;
    }

    public void setCreatedatetime(Date createdatetime) {
        this.createdatetime = createdatetime;
    }

    @Temporal(TemporalType.TIMESTAMP)
    @Column(name = "MODIFYDATETIME", length = 7)
    public Date getModifydatetime() {
        return this.modifydatetime;
    }

    public void setModifydatetime(Date modifydatetime) {
        this.modifydatetime = modifydatetime;
    }
}
在com.cosconet.test中创建 TestHibernate 类，如下图所示：

代码如下： 
package com.cosconet.test;

import java.util.Date;
import java.util.UUID;

import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.hibernate.cfg.Configuration;
import org.junit.Test;

import com.cosconet.model.User;

public class TestHibernate {

	@Test
	public void save()
	{
                User user = new User();
                user.setId(UUID.randomUUID().toString().replaceAll("-", ""));
                user.setName("哈宇华帝");
                user.setPwd("123");
                user.setCreatedatetime(new Date());  
		Configuration cfg = new Configuration();   
		SessionFactory cf = cfg.configure().buildSessionFactory();   
		Session session = cf.openSession();   
		session.beginTransaction();   
		session.save(user);   
		session.getTransaction().commit();   
		session.close();   
		cf.close(); 
	}
}
运行测试 TestHibernate，结果如下：

查看数据库，数据已新增进入，说明hibernate的环境搭建成功。

四.struts2与spring整合

1.下载struts2和Spring整合时需要使用到的插件
   1.struts2-spring-plugin(struts2和Spring整合时需要使用到的插件)
在pom.xml文件中编写struts2和Spring整合时需要使用到的插件需要的jar包：
 
		<!-- Struts2和Spring整合插件 -->  
		<dependency>  
		    <groupId>org.apache.struts</groupId>  
		    <artifactId>struts2-spring-plugin</artifactId>  
		    <version>2.3.4.1</version>  
		</dependency>
2.配置struts.xml，指定spring负责ation的创建 
    <!-- 指定由spring负责action对象的创建 -->  
    <constant name="struts.objectFactory" value="spring" />
3.在TestAction注入userService，代码如下 
package com.cosconet.action;

import org.apache.struts2.convention.annotation.Action;
import org.apache.struts2.convention.annotation.Namespace;
import org.apache.struts2.convention.annotation.ParentPackage;
import org.apache.struts2.convention.annotation.Result;
import org.apache.struts2.convention.annotation.Results;
import org.springframework.beans.factory.annotation.Autowired;

import com.cosconet.service.UserServiceI;

@ParentPackage("basePackage")
@Action(value="strust2Test")//使用convention-plugin插件提供的@Action注解将一个普通java类标注为一个可以处理用户请求的Action，Action的名字为struts2Test
@Namespace("/")//使用convention-plugin插件提供的@Namespace注解为这个Action指定一个命名空间
@Results( { @Result(name = "success", location = "/success.jsp"),
	@Result(name = "input", location = "/register.jsp") })
public class TestAction {
    
    /** 
     * 注入userService 
     */  
    @Autowired  
    private UserServiceI userService;

    public TestAction() {
		super();
	}

	/**
     * http://localhost:8080/SSHE/strust2Test!test.action
     * MethodName: test
     * Description: 
     * @author xudp
     */
    public String test(){
        System.out.println("进入TestAction");
        userService.test();
        return "success";
    }
}
4.启动tomcat，访问http://localhost:8080/COSCONET/strust2Test!test.action，结果如下：


struts2与spring3整合成功。

五.spring与hibernate整合

1.编写数据库连接配置信息文件config.properties，如下图：


配置如下：
 
#hibernate.dialect=org.hibernate.dialect.OracleDialect  
#driverClassName=oracle.jdbc.driver.OracleDriver  
#validationQuery=SELECT 1 FROM DUAL  
#jdbc_url=jdbc:oracle:thin:@127.0.0.1:1521:orcl  
#jdbc_username=gacl  
#jdbc_password=xdp  
  
  
#hibernate.dialect=org.hibernate.dialect.MySQLDialect  
#driverClassName=com.mysql.jdbc.Driver  
#validationQuery=SELECT 1  
#jdbc_url=jdbc:mysql://localhost:3306/sshe?useUnicode=true&characterEncoding=UTF-8&zeroDateTimeBehavior=convertToNull  
#jdbc_username=root  
#jdbc_password=XDP  
  
  
hibernate.dialect=org.hibernate.dialect.SQLServerDialect  
driverClassName=com.microsoft.sqlserver.jdbc.SQLServerDriver  
validationQuery=SELECT 1  
jdbc_url=jdbc\:sqlserver\://172.25.6.146\:1433;DatabaseName\=xsjdd;SelectMethod\=cursor;  
jdbc_username=sa  
jdbc_password=cosnet  
  
  
#jndiName=java:comp/env/dataSourceName  
  
  
hibernate.hbm2ddl.auto=update  
hibernate.show_sql=true  
hibernate.format_sql=true
2.编写hibernate与spring整合的配置文件
在src/main/resources目录下新建一个spring-hibernate.xml文件，如下图所示：


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: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-3.0.xsd 
http://www.springframework.org/schema/tx 
http://www.springframework.org/schema/tx/spring-tx-3.0.xsd
http://www.springframework.org/schema/aop 
http://www.springframework.org/schema/aop/spring-aop-3.0.xsd
">

    <!-- JNDI方式配置数据源 -->
    <!-- 
    <bean id="dataSource" class="org.springframework.jndi.JndiObjectFactoryBean">
         <property name="jndiName" value="${jndiName}"></property> 
    </bean> 
    -->
    <!-- 配置数据源 -->
	<bean id="dataSource" class="org.apache.commons.dbcp.BasicDataSource">
		<property name="driverClassName" value="com.microsoft.sqlserver.jdbc.SQLServerDriver" />
		<property name="url" value="${jdbc_url}" />
		<property name="username" value="${jdbc_username}" />
		<property name="password" value="${jdbc_password}" />
    </bean>

    <!-- 配置hibernate 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>
            </props>
        </property>

        <!-- 自动扫描注解方式配置的hibernate类文件 -->
        <property name="packagesToScan">
            <list>
                <value>me.gacl.model</value>
            </list>
        </property>

        <!-- 自动扫描hbm方式配置的hibernate文件和.hbm文件 -->
        <!-- 
        <property name="mappingDirectoryLocations">
            <list>
                <value>classpath:me/gacl/model/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 id="transactionPointcut" expression="execution(* me.gacl.service..*Impl.*(..))" />
        <aop:advisor pointcut-ref="transactionPointcut" advice-ref="transactionAdvice" />
    </aop:config>
    
</beans>
3.编写测试
在src/main/java中创建com.cosconet.dao包，在包中编写一个 UserDaoI接口，如下图所示：
代码如下： 
package com.cosconet.dao;

import java.io.Serializable;

import com.cosconet.model.User;

public interface UserDaoI {

    /**
     * 保存用户
     * @param user
     * @return
     */
    Serializable save(User user); 
}
在src/main/java中创建com.cosconet.dao.impl包，在包中编写 UserDaoImpl实现类，如下图所示：


代码如下： 
package com.cosconet.dao.impl;  
  
import java.io.Serializable;  
  
import org.hibernate.SessionFactory;  
import org.springframework.beans.factory.annotation.Autowired;  
import org.springframework.stereotype.Repository;  
  
import com.cosconet.dao.UserDaoI;  
import com.cosconet.model.User;  
  
@Repository("userDao")  
public class UserDaoImpl implements UserDaoI {  
      
    /** 
     * 使用@Autowired注解将sessionFactory注入到UserDaoImpl中 
     */  
    @Autowired  
    private SessionFactory sessionFactory;  
      
    @Override  
    public Serializable save(User user) {  
        return sessionFactory.getCurrentSession().save(user);  
    }  
}
这里使用@Repository("userDao")注解完成dao注入， 使用@Autowired注解将sessionFactory注入到UserDaoImpl中。
在之前创建好的UserServiceI接口中添加一个save方法的定义，如下： 
package com.cosconet.service;

import java.io.Serializable;

import com.cosconet.model.User;

public interface UserServiceI {

    /**
     * 测试方法
     */
    void test();
    
    /** 
     * 保存用户 
     * @param user 
     * @return 
     */  
    Serializable save(User user); 
}
在UserServiceImpl类中实现save方法，如下： 
package com.cosconet.service.impl;

import java.io.Serializable;

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

import com.cosconet.dao.UserDaoI;
import com.cosconet.model.User;
import com.cosconet.service.UserServiceI;

//使用Spring提供的@Service注解将UserServiceImpl标注为一个Service
@Service("userService")
public class UserServiceImpl implements UserServiceI {

    /** 
     * 注入userDao 
     */  
    @Autowired  
    private UserDaoI userDao; 
	
  @Override
  public void test() {
      System.out.println("Hello World!");
  }

  @Override  
  public Serializable save(User user) {  
      return userDao.save(user);  
  }  
}
在src/main/test下的com.cosconet.test包中编写 TestSpringHibernate类，代码如下： 
package com.cosconet.test;

import java.util.Date;
import java.util.UUID;

import org.junit.Before;
import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

import com.cosconet.model.User;
import com.cosconet.service.UserServiceI;

public class TestSpringHibernate {
	
    private UserServiceI userService;  
    
    /** 
     * 这个before方法在所有的测试方法之前执行，并且只执行一次 
     * 所有做Junit单元测试时一些初始化工作可以在这个方法里面进行 
     * 比如在before方法里面初始化ApplicationContext和userService 
     */  
    @Before  
    public void before(){  
        ApplicationContext ac = new ClassPathXmlApplicationContext(new String[]{"spring.xml","spring-hibernate.xml"});  
        userService = (UserServiceI) ac.getBean("userService");  
    }  
      
    @Test  
    public void testSaveMethod(){  
        //ApplicationContext ac = new ClassPathXmlApplicationContext(new String[]{"spring.xml","spring-hibernate.xml"});  
        //UserServiceI userService = (UserServiceI) ac.getBean("userService");  
        User user = new User();  
        user.setId(UUID.randomUUID().toString().replaceAll("-", ""));  
        user.setName("哈宇华帝2");  
        user.setPwd("123");  
        user.setCreatedatetime(new Date());   
        userService.save(user);  
    }
}
执行结果如下：

测试成功，数据成功保存到数据库，spring与hibernate整合完成。

六.三大框架整合测试

1.在web.xml中添加classpath:spring-hibernate.xm到spring的配置参数中 
<!-- Spring配置文件位置 -->  
<context-param>  
    <param-name>contextConfigLocation</param-name>  
    <param-value>classpath:spring.xml,classpath:spring-hibernate.xml</param-value>  
</context-param>
2.在TestAction中增加saveUser方法，代码如下： 
package com.cosconet.action;

import java.util.Date;
import java.util.UUID;

import org.apache.struts2.convention.annotation.Action;
import org.apache.struts2.convention.annotation.Namespace;
import org.apache.struts2.convention.annotation.ParentPackage;
import org.apache.struts2.convention.annotation.Result;
import org.apache.struts2.convention.annotation.Results;
import org.springframework.beans.factory.annotation.Autowired;

import com.cosconet.model.User;
import com.cosconet.service.UserServiceI;

@ParentPackage("basePackage")
@Action(value="strust2Test")//使用convention-plugin插件提供的@Action注解将一个普通java类标注为一个可以处理用户请求的Action，Action的名字为struts2Test
@Namespace("/")//使用convention-plugin插件提供的@Namespace注解为这个Action指定一个命名空间
@Results( { @Result(name = "success", location = "/success.jsp"),
	@Result(name = "input", location = "/register.jsp") })
public class TestAction {
    
    /** 
     * 注入userService 
     */  
    @Autowired  
    private UserServiceI userService;

    public TestAction() {
		super();
	}

	/**
     * http://localhost:8080/SSHE/strust2Test!test.action
     * MethodName: test
     * Description: 
     * @author xudp
     */
    public String test(){
        System.out.println("进入TestAction");
        userService.test();
        return "success";
    }
    
    /** 
     * http://localhost:8080/SSHE/strust2Test!saveUser.action 
     */  
    public void saveUser(){  
        User user = new User();  
        user.setId(UUID.randomUUID().toString().replaceAll("-", ""));  
        user.setName("哈宇华帝5");  
        user.setPwd("123456");  
        user.setCreatedatetime(new Date());   
        userService.save(user);  
    } 
}
启动tomcat,访问http://localhost:8080/COSCONET/strust2Test!saveUser.action，结果如下：

查询数据库，数据已成功保存到数据库，至此，三大框架整合完成。




版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/fenyu8/article/details/52997784

智能推荐

制作一个广告字幕滚动效果的网页的心路历程_网页的滚动广告-程序员宅基地

文章浏览阅读823次。先看效果刚开始的需求是，制作一个类似电视广告字幕的效果，我没什么思路，后来看了字幕的实现方式，就是用css动画的移动实现,于是我开始了对这段动画的驾驭。我们写一个外面的块，宽度是100%，再写一个里面的块，再里面的块里放置内容。内容部分暂且不管，我主要讲实现思路。<body> <div id="app"> <template> <div class="marquee-outer-wrapper"&g._网页的滚动广告

RBF径向基神经网络多输入单输出的MATLAB实现_rbfs-程序员宅基地

文章浏览阅读161次。通过选择合适的径向基函数和调节相关参数，我们可以构建一个有效的神经网络模型，并利用其进行预测和函数逼近。输入层用于接收输入数据，隐藏层包含一组径向基函数，用于进行特征映射，输出层用于产生最终的预测结果。首先，我们需要准备训练数据。其中，P是输入数据，T是输出数据，goal是目标训练误差，spread是径向基函数的宽度参数，MN是隐藏层神经元的最小和最大数量，DF是隐藏层神经元扩展的步长。函数创建了一个RBF神经网络，设置了目标训练误差为0.1，径向基函数的宽度参数为1，隐藏层神经元的数量范围为10到15。_rbfs

燕大通勤车-程序员宅基地

文章浏览阅读50次。一，每一辆成功的燕大通勤车上，都有一个玩命的司机。二，燕大通勤车的空间就像海绵，挤挤总会有的。三，挤是一个客观发展的必然过程，比如说你在一二组团之间等车觉得车挤，往回走一站上车，到了大坡下站牌还得挤。四，大三学生：我的理想就是在我离校之前能挤上一次通勤车。五，先上车被踩，后上者踩其上。六，不是看谁先上车，坐到最后的才是赢家。七，上了燕大通勤车，把孟婆汤一喝，今生今世所有的痛苦都忘了。八，“阴间怎么...

php 面试题-程序员宅基地

文章浏览阅读195次。1.请自我介绍一下?答:我叫xxx,来自北京,20xx年毕业于xx大学计算机xx系,毕业后在武汉从事了x年的php开发工作,公司是一个外包公司,主要做微信开发,公众号推广,商城,论坛的开发2.你在公司负责那些项目?答:由于我们公司是一个外包公司,不可能只做一个项目,公司的项目都是交叉进行的,论坛,微信,商城我都做过?3.你为什么来深圳?答:因为我哥在这边,父母也希望兄弟间有个照...

MyBatis Plus (三) --------- 入门 HelloWorld_mybatis-plus helloword-程序员宅基地

文章浏览阅读238次。MyBatis Plus 使用入门_mybatis-plus helloword

BERT模型对抗性攻击分析研究：了解对抗样本及防御方法_bert对抗攻击-程序员宅基地

文章浏览阅读560次，点赞4次，收藏8次。BERT模型基本原理简介BERT（Bidirectional Encoder Representations from Transformers）是一种基于Transformer架构的预训练语言模型，其核心思想是通过双向上下文来学习文本表示。双向注意力机制：BERT模型使用Transformer中的注意力机制来实现双向编码，能够充分考虑位置前后的上下文信息。多层Transformer编码器。_bert对抗攻击

随便推点

多元预测|开普勒算法优化注意力机制卷积神经网络结合双向门控循环单元KOA-Attention-CNN-biGRU实现光伏预测附matlab代码-程序员宅基地

文章浏览阅读1.4k次，点赞9次，收藏10次。光伏预测是光伏发电系统稳定运行和电网安全的重要保障。本文提出了一种基于开普勒算法优化注意力机制卷积神经网络结合双向门控循环单元（KOA-Attention-CNN-biGRU）的光伏预测模型。该模型通过开普勒算法优化注意力机制，增强了模型对光伏时间序列数据的局部特征提取能力；同时，结合双向门控循环单元，充分利用了光伏时间序列数据的长期依赖关系，提高了预测精度。在北神山光伏电站实际数据上的实验结果表明，所提出的模型在预测精度和鲁棒性方面均优于传统的光伏预测模型。引言。

2016，自律又惊喜的一年-程序员宅基地

文章浏览阅读143次。2016年度目标完成情况跑步，完成一次半程马拉松（已完成）练成六块腹肌（未完成，只有一块腹肌，应该是七分吃，三分练）趁早效率手册、三只青蛙、番茄工作法、践行GTD、100小时定律（践行效率不高，但基本都在做）敢于表达自我，专注于演讲技能 ，10次演讲 （8/10）英语能力提升，练习口语和阅读（上半年是以英语单词打卡为主，下半年是以英语每日一句，英语麦克风打卡，听的用开言英语，阅读是...

Pandas基础介绍-程序员宅基地

文章浏览阅读945次，点赞19次，收藏20次。Pandas 是一个开源的数据分析和数据处理库，它是基于 Python 编程语言的。Pandas 提供了易于使用的数据结构和数据分析工具，特别适用于处理结构化数据，如表格型数据（类似于Excel表格）。Pandas 是数据科学和分析领域中常用的工具之一，它使得用户能够轻松地从各种数据源中导入数据，并对数据进行高效的操作和分析。Pandas官网地址Pandas文档。_pandas

mac webrtc android,WebRTC 开发（五）编译与运行 Mac 工程-程序员宅基地

文章浏览阅读151次。Last login: Fri Oct 18 20:59:20 on ttys000The default interactive shell is now zsh.To update your account to use zsh, please run `chsh -s /bin/zsh`.For more details, please visit https://support.apple..._ardexternalsamplecapturer

::在C++中的意思_c++ ::代表-程序员宅基地

文章浏览阅读934次。::表示作用域，和所属关系。class Aint A::test() //表示test是属于A类的。关于::的具体解析：::是运算符中等级最高的，它分为三种:1)global scope(全局作用域符），用法（::name)。2)class scope(类作用域符），用法(class::name)。3)namespace scope(命名空间作用域符），用法(namespace::n..._c++ ::代表

如何在Arcgis中对图斑进行自上而下，从左往右地编号_arcgis编号号从上到下,从左到右-程序员宅基地

文章浏览阅读3w次，点赞20次，收藏90次。在实际项目中，需要我们按照自上而下，从左往右的顺序为图斑编号，并且多数时候序号位数是确定的，针对这个问题我总结了一个自认为还算简便的方法。下面是具体的方法步骤：1、计算Xmin与Ymax。利用坐标进行排序，首先要算出坐标值。需要说明的是这里没有直接利用质心坐标而采用Xmin、Ymax进行排序，是因为质心坐标会遇到一种情况，就是当这个图斑很长或者很宽时，本应排在前面的序号，而因为质心靠后不得不被..._arcgis编号号从上到下,从左到右

推荐文章

热门文章

相关标签