Maven构建与管理项目(四)
使用Maven搭建Struts2框架的开发环境
创建基于Maven的Web项目
我使用的是MyEclipse8.5的版本,创建好的Web项目如下所示:
我们知道,一个标准的Maven项目是必须包括【src/main/java】,【src/main/resources】,【src/test/java】,【src/test/resources】这四个Source Folder的,而创建好的项目当中只有一个(不懂为啥MyEclipse8.5没有帮我生成【src/main/java】),所以我们还需要手动创建剩下的【src/main/java】,【src/test/java】,【src/test/resources】这三个Source Folder,以创建【src/main/java】为例,具体步骤如下:
点击【Finish】按钮完成创建,如下图所示:
【src/test/java】,【src/test/resources】也是采用相同的方式进行创建,这里用一张动态的gif动画演示一下创建过程,如下图所示:
最终效果如下:
这样我们的【Struts2AnnotationMavenProject】项目才是一个标准的Maven项目,我们可以使用Maven来构建一下【Struts2AnnotationMavenProject】项目,看看能否正常构建成功,如下图所示:
从运行结果显示,项目可以正常构建成功。
搭建Struts2的开发环境
添加Struts2框架的核心jar包
由于我们是使用Maven管理项目中的jar包的,所以我们需要在pom.xml文件中添加Struts2框架的核心jar包的描述。
编辑pom.xml文件,添加添加Struts2框架的核心jar包的描述,如下:
<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>me.gacl</groupId>
<artifactId>Struts2AnnotationMavenProject</artifactId>
<packaging>war</packaging>
<version>0.0.1-SNAPSHOT</version>
<name>Struts2AnnotationMavenProject Maven Webapp</name>
<url>http://maven.apache.org</url>
<dependencies>
<dependency>
<groupId>junit</groupId>
<artifactId>junit</artifactId>
<version>3.8.1</version>
<scope>test</scope>
</dependency>
<!-- Struts2的核心包 -->
<dependency>
<groupId>org.apache.struts</groupId>
<artifactId>struts2-core</artifactId>
<version>2.3.16</version>
</dependency>
</dependencies>
<build>
<finalName>Struts2AnnotationMavenProject</finalName>
</build>
</project>
pom.xml文件中标红的部分就是我们添加的Struts2框架的核心jar包的描述,保存pom.xml文件,此时Maven就会自动帮我们把struts2-core这个jar包依赖的其他相关jar包导入到我们的Web项目当中,如下图所示:
添加Struts2框架的配置文件struts.xml
Maven约定,web项目开发中的使用到的配置文件都要放到【src/main/resources】这个Source Folder下,如下图所示:
编辑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" />
<!-- 是否启用开发模式 -->
<constant name="struts.devMode" value="true" />
<!-- struts配置文件改动后,是否重新加载 -->
<constant name="struts.configuration.xml.reload" value="true" />
<!-- 设置浏览器是否缓存静态内容 -->
<constant name="struts.serve.static.browserCache" value="false" />
<!-- 请求参数的编码方式 -->
<constant name="struts.i18n.encoding" value="utf-8" />
<!-- 每次HTTP请求系统都重新加载资源文件,有助于开发 -->
<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>
convention-plugin和config-browser-plugin插件介绍
以前用struts2框架开发项目时,每次编写好一个Action,就需要在struts.xml文件中配置Action,而convention-plugin这个插件的出现出现后,就不再需要在struts.xml文件中配置Action了,convention-plugin提供了一种非常方便的注解方式来配置Action类。
convention-plugin采用"约定大于配置”的思想,只要我们遵守约定,完全可以少写配置甚至不写配置;config-browser-plugin插件则用于方便的浏览项目中的所有action及其与 jsp view的映射。这二个插件结合起来学习,能很方便的搞定struts2中各种复杂的action-view映射需求,所以现在使用Struts2框架开发Web应用时,一般都会配合这两个插件一起使用。
convention-plugin和config-browser-plugin插件使用
为了方便使用Struts2框架,我们最好在项目中配合convention-plugin、 config-browser-plugin这两个插件一起使用,在maven项目的pom.xml中加上这两个插件的jar包描述,如下:
<!-- 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>
在web.xml文件中配置Struts2的核心过滤器
<?xml version="1.0" encoding="UTF-8"?>
<web-app version="2.5"
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_2_5.xsd">
<display-name>Archetype Created Web Application</display-name>
<!-- add struts2 configiguration -->
<filter>
<description>配置struts2的核心过滤器</description>
<filter-name>struts2</filter-name>
<filter-class>org.apache.struts2.dispatcher.ng.filter.StrutsPrepareAndExecuteFilter</filter-class>
</filter>
<filter-mapping>
<filter-name>struts2</filter-name>
<url-pattern>*.action</url-pattern>
</filter-mapping>
<!-- end add struts2 configuration-->
</web-app>
测试Struts2框架是否搭建成功
编写一个TestAction类,用于测试
package me.gacl.action;
import org.apache.struts2.convention.annotation.Action;
import org.apache.struts2.convention.annotation.Namespace;
@ParentPackage("basePackage")
//使用convention插件提供的@Action注解将一个普通Java类标识为可以处理用户请求的Action类
@Action
//使用使用convention插件提供的@Namespace注解指明这个Action类的命名空间
@Namespace("/")
public class TestAction {
/**
* test方法的访问方式:http://localhost:8080/Struts2AnnotationMavenProject/test!test
* MethodName: test
* Description:
* @author xudp
*/
public void test(){
System.out.println("调用了TestAction里面的test方法");
}
}
在将类使用@Action注解标识时发现@Action注解必须使用JDK1.6才行,所以我修改了JDK的版本,改成使用JDK1.6的,如下图所示:
由于使用了convention-plugin插件的提供的注解方式映射Action的访问路径,所以我们不再需要像以前那样在Struts.xml文件中配置Action的访问路径了,测试结果如下:
可以看到,我们的TestAction里面的test方法已经成功调用了,这说明我们的Struts2框架的开发环境搭建成功。并且我们也感受到了使用convention-plugin插件开发基于注解的Struts2程序是非常方便和快捷的。
我们的项目中还使用到了config-browser-plugin插件,下面我们来感受一下这个config-browser-plugin插件带来的便利之处
输入访问URL:http://localhost:8080/项目名/config-browser/index.action来访问config-browser-plugin插件提供的视图页面,例如:http://localhost:8080/Struts2AnnotationMavenProject/config-browser/index.action,这样就可以进入config-browser-plugin插件提供的视图界面,如下图所示:
以上就是在MyEclipse中使用Maven搭建Struts2框架的开发环境的相关介绍,使用了Maven之后,大大提高了框架开发环境的搭建速度,起码我们不再需要关心Struts2框架的开发环境需要哪些jar包,我们只需要引入Struts2的核心jar包struts2-core,然后Maven就会自动帮我们把struts2-core这个jar包的相关依赖jar全部加入到项目中,将web应用中的jar包全部交给Maven进行管理是一种非常好的做法,现在主流的项目都是采用Maven进行构建的。
使用Maven搭建Struts2+Spring3+Hiberante4整合开发环境
在平时的JavaEE开发中,为了能够用最快的速度开发项目,一般都会选择使用Struts2,SpringMVC,Spring,Hibernate,MyBatis这些开源框架来开发项目,而这些框架一般不是单独使用的,经常是Struts2+Spring3+Hibernate、SpringMVC+Spring+Hibernate、SpringMVC+Spring+Mybatis这几种组合中的一种,也就是多个框架配合起来使用。
建立Maven工程
第一步:
第二步:
第三步:
创建好的项目如下图所示:
第四步:
注意:这里的JDK要选择默认的,这样别人在使用的时候,如何JDk不一致的话也不会出错,如下图所示:
第五步:
创建Maven标准目录
src/main/java
src/main/resources
src/test/java
src/test/resources
第六步:
发布项目:Maven install
清除编译过的项目:Maven clean
Maven install命令执行结果如下:
OK,Maven工程创建成功!
搭建Spring3开发环境
下载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>
编写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="me.gacl.dao,me.gacl.service" />
</beans>
在src/main/resources目录下创建一个config.properties文件,如下图所示:
config.properties文件主要是用来编写一些系统的配置信息,例如数据库连接信息,config.properties文件中的内容暂时先不编写,等整合到Hibernate时再编写具体的数据库连接信息。
编写单元测试
首先,在src/main/java中创建me.gacl.service包,在包中编写一个 UserServiceI 接口,如下图所示:
代码如下:
package me.gacl.service;
/**
* 测试
* @author gacl
*
*/
public interface UserServiceI {
/**
* 测试方法
*/
void test();
}
然后,在src/main/java中创建me.gacl.service.impl包,在包中编写UserServiceImpl实现类,如下图所示:
package me.gacl.service.impl;
import org.springframework.stereotype.Service;
import me.gacl.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包描述,如下:
<!-- 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中创建me.gacl.test包,在包中编写 TestSpring类,如下图所示:
代码如下:
package me.gacl.test;
import me.gacl.service.UserServiceI;
import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
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运行,结果如图所示:
在web.xml中配置Spring监听器
<!-- 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>
在tomcat服务器中进行测试,先执行【Maven install】命令发布项目,然后将SSHE项目部署到tomcat服务器,最后启动tomcat服务器
tomcat服务器启动的过程中没有出现报错,输入地址:http://localhost:8080/SSHE/ 能够正常进行访问,就说明Spring3的开发环境搭建成功,如下图所示:
测试通过,Spring3开发环境搭建成功!
搭建Struts2开发环境并整合Spring3
下载Struts2需要的jar包
1.strtus2-core
2.struts2-spring-plugin(struts2和Spring整合时需要使用到的插件)
3.struts2-convention-plugin(使用了这个插件之后,就可以采用注解的方式配置Struts的Action,免去了在struts.xml中的繁琐配置项)
4.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>
<!--
这里的 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>
<!--config-browser-plugin插件,使用了这个插件之后,就可以很方便的浏览项目中的所有action及其与 jsp view的映射 -->
<dependency>
<groupId>org.apache.struts</groupId>
<artifactId>struts2-config-browser-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>
编写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>
<!-- 指定由spring负责action对象的创建 -->
<constant name="struts.objectFactory" value="spring" />
<!-- 所有匹配*.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>
在web.xml中配置Struts2的过滤器
<!-- 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>
编写测试
首先,在src/main/java中创建me.gacl.action包,在包中编写一个 TestAction类,如下图所示:
代码如下:
package me.gacl.action;
import me.gacl.service.UserServiceI;
import org.apache.struts2.convention.annotation.Action;
import org.apache.struts2.convention.annotation.Namespace;
import org.apache.struts2.convention.annotation.ParentPackage;
import org.springframework.beans.factory.annotation.Autowired;
@ParentPackage("basePackage")
@Action(value="strust2Test")//使用convention-plugin插件提供的@Action注解将一个普通java类标注为一个可以处理用户请求的Action,Action的名字为struts2Test
@Namespace("/")//使用convention-plugin插件提供的@Namespace注解为这个Action指定一个命名空间
public class TestAction {
/**
* 注入userService */
@Autowired
private UserServiceI userService;
/**
* http://localhost:8080/SSHE/strust2Test!test.action
* MethodName: test
* Description:
* @author xudp
*/
public void test(){
System.out.println("进入TestAction");
userService.test();
}
}
这里使用@Autowired注解将userService注入到UserAction中。
测试Struts2的开发环境是否搭建成功,先执行【Maven install】操作,然后部署到tomcat服务器,最后启动tomcat服务器运行,
输入访问地址:http://localhost:8080/SSHE/strust2Test!test.action,访问结果如下:
测试通过,Struts2的开发环境搭建并整合Spring成功!这里提一下遇到的问题,我执行完Maven install命令之后,重新发布到tomcat服务器运行,第一次运行时出现了找不到action的404错误,后来就先执行Maven clean,然后clean一下项目,再执行Maven install命令重新编译项目,然后再发布到tomcat服务器中运行,这次就可以正常访问到action了,使用Maven总是会遇到一些奇怪的问题,好在凭借着一些平时积累的解决问题的经验把问题解决了。
搭建Hibernate4开发环境并整合Spring3
下载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>
</dependency>
注意:一定要排除掉Struts2中的javassist,否则就冲突了。
添加数据库驱动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:
<!-- SQLServer数据库驱动包 -->
<dependency>
<groupId>net.sourceforge.jtds</groupId>
<artifactId>jtds</artifactId>
<version>1.3.1</version>
</dependency>
这里要说一下使用Maven管理Oracle JDBC驱动的问题了,正常情况下,Maven在下载 oracle数据库驱动时会出错,如下图所示:
这是由于Oracle授权问题,Maven3不提供Oracle JDBC driver,为了在Maven项目中应用Oracle JDBC driver,必须手动添加到本地仓库。
解决办法:先从网上下载Oracle的驱动包,然后通过Maven命令放到本地库中去:
安装命令:
mvn install:install-file -Dfile={Path/to/your/ojdbc.jar} -DgroupId=com.oracle -DartifactId=ojdbc6 -Dversion=11.2.0.1.0 -Dpackaging=jar
例如把位于F:\oracle驱动\ojdbc6.jar添加到本地仓库中
执行命令:
mvn install:install-file -Dfile=F:/oracle驱动/ojdbc6.jar -DgroupId=com.oracle -DartifactId=ojdbc6 -Dversion=11.2.0.1.0 -Dpackaging=jar
如下图所示:
然后在pom.xml文件中编写ojdbc6.jar包的<dependency>信息,如下所示:
<!--Oracle数据库驱动包,针对Oracle11.2的ojdbc6.jar -->
<dependency>
<groupId>com.oracle</groupId>
<artifactId>ojdbc6</artifactId>
<version>11.2.0.1.0</version>
</dependency>
由于我们已经将ojdbc6.jar包加入到本地仓库中了,因此这次可以正常使用针对Oracle数据库的驱动包了。如下图所示:
添加数据库连接池jar包
在平时开发中,我们一般都会使用数据库连接池,应用系统初始化时,由数据库连接池向数据库申请一定数量的数据库连接,然后放到一个连接池中,当需要操作数据库时,就从数据库连接池中取出一个数据库连接,通过从连接池中获取到的数据库连接对象连接上数据库,然后进行CRUD操作,关于数据库连接池的选择,常用的有DBCP,C3P0和Druid,这里我们使用Druid作为我们的数据库连接池。这三种连接池各自有各自的特点,自己熟悉哪个就用哪个,萝卜白菜,各有所爱。
在pom.xml文件中编写Druid的jar包,Maven会自动下载,如下:
<!--Druid连接池包 -->
<dependency>
<groupId>com.alibaba</groupId>
<artifactId>druid</artifactId>
<version>1.0.12</version>
</dependency>
添加aspectjweaver包
使用Spring的aop时需要使用到aspectjweaver包,所以需要添加aspectjweaver包,在pom.xml文件中添加aspectjweaver的jar包,Maven会自动下载,如下:
!--aspectjweaver包 -->
<dependency>
<groupId>org.aspectj</groupId>
<artifactId>aspectjweaver</artifactId>
<version>1.8.5</version>
</dependency>
编写连接数据库的配置信息
之前我们在src/main/resources目录下创建了一个config.properties文件,里面的内容是空的,现在我们就在这个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=net.sourceforge.jtds.jdbc.Driver
#validationQuery=SELECT 1
#jdbc_url=jdbc:jtds:sqlserver://127.0.0.1:1433/sshe
#jdbc_username=sa
#jdbc_password=123456
#jndiName=java:comp/env/dataSourceName
hibernate.hbm2ddl.auto=update
hibernate.show_sql=true
hibernate.format_sql=true
编写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 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="true" /> <property name="maxPoolPreparedStatementPerConnectionSize" value="33" /> -->
<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="stat" /> -->
<property name="filters" value="mergeStat" />
</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>
编写单元测试代码
1、在MySQL中创建sshe数据库
SQL脚本:
CREATE DATABASE SSHE;
2、在src/main/java中创建me.gac.model包,在包中编写一个 User类,如下图所示:
代码如下:
package me.gacl.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 = "T_USER", schema = "SSHE")
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;
}
}
3、在src/main/java中创建me.gacl.dao包,在包中编写一个 UserDaoI接口,如下图所示:
代码如下:
package me.gacl.dao;
import java.io.Serializable;
import me.gacl.model.User;
public interface UserDaoI {
/**
* 保存用户
* @param user
* @return
*/
Serializable save(User user);
}
在src/main/java中创建me.gacl.dao.impl包,在包中编写 UserDaoImpl实现类,如下图所示:
代码如下:
package me.gacl.dao.impl;
import java.io.Serializable;
import org.hibernate.SessionFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Repository;
import me.gacl.dao.UserDaoI;
import me.gacl.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中。
4、在之前创建好的UserServiceI接口中添加一个save方法的定义,如下:
package me.gacl.service;
import java.io.Serializable;
import me.gacl.model.User;
/**
* 测试
* @author gacl
*
*/
public interface UserServiceI {
/**
* 测试方法
*/
void test();
/**
* 保存用户
* @param user
* @return
*/
Serializable save(User user);
}
5、在UserServiceImpl类中实现save方法,如下:
package me.gacl.service.impl;
import java.io.Serializable;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import me.gacl.dao.UserDaoI;
import me.gacl.model.User;
import me.gacl.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);
}
}
6、在src/main/test下的me.gacl.test包中编写 TestHibernate类,代码如下:
package me.gacl.test;
import java.util.Date;
import java.util.UUID;
import me.gacl.model.User;
import me.gacl.service.UserServiceI;
import org.junit.Before;
import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
public class TestHibernate {
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("孤傲苍狼");
user.setPwd("123");
user.setCreatedatetime(new Date());
userService.save(user);
}
}
执行Junit单元测试,如下所示:
测试通过,再看看sshe数据库,如下图所示:
Hibernate在执行过程中,先帮我们在sshe数据库中创建一张t_user表,t_user的表结构根据User实体类中的属性定义来创建的,然后再将数据插入到t_user表中,如下图所示:
到此,Hibernate4开发环境的搭建并且与Spring整合的工作算是全部完成并且测试通过了。
三大框架综合测试
经过前面的四大步骤,我们已经成功地搭建好基于struts2+hibernate4+spring3这三大框架的整合开发环境,下面我们来综合测试一下三大框架配合使用进行开发的效果。
完善web.xml文件中的配置
<?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>
<!-- 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,classpath:spring-hibernate.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>
</web-app>
编写测试代码
在TestAction类中添加一个saveUser方法,如下:
package me.gacl.action;
import java.util.Date;
import java.util.UUID;
import me.gacl.model.User;
import me.gacl.service.UserServiceI;
import org.apache.struts2.convention.annotation.Action;
import org.apache.struts2.convention.annotation.Namespace;
import org.apache.struts2.convention.annotation.ParentPackage;
import org.springframework.beans.factory.annotation.Autowired;
@ParentPackage("basePackage")
@Action(value="strust2Test")//使用convention-plugin插件提供的@Action注解将一个普通java类标注为一个可以处理用户请求的Action
@Namespace("/")//使用convention-plugin插件提供的@Namespace注解为这个Action指定一个命名空间
public class TestAction {
/**
* 注入userService
*/
@Autowired
private UserServiceI userService;
/**
* http://localhost:8080/SSHE/strust2Test!test.action
* MethodName: test
* Description:
* @author xudp
*/
public void test(){
System.out.println("进入TestAction");
userService.test();
}
/**
* http://localhost:8080/SSHE/strust2Test!saveUser.action
*/
public void saveUser(){
User user = new User();
user.setId(UUID.randomUUID().toString().replaceAll("-", ""));
user.setName("xdp孤傲苍狼");
user.setPwd("123456");
user.setCreatedatetime(new Date());
userService.save(user);
}
}
执行【Maven install】操作,重新编译和发布项目,在执行【Maven install】操作之前,需要修改TestSpring这个测试类中的test方法的代码,如下:
package me.gacl.test;
import me.gacl.service.UserServiceI;
import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
public class TestSpring {
@Test
public void test(){
//通过spring.xml配置文件创建Spring的应用程序上下文环境
//ApplicationContext ac = new ClassPathXmlApplicationContext("classpath:spring.xml");
/**
*因为已经整合了Hibernate,UserServiceImpl类中使用到了userDao,
*userDao是由spring创建并且注入给UserServiceImpl类的,而userDao中又使用到了sessionFactory对象
*而创建sessionFactory对象时需要使用到spring-hibernate.xml这个配置文件中的配置项信息,
*所以创建Spring的应用程序上下文环境时,需要同时使用spring.xml和spring-hibernate.xml这两个配置文件
*否则在执行Maven install命令时,因为maven会先执行test方法中的代码,而代码执行到
*UserServiceI userService = (UserServiceI) ac.getBean("userService");
*这一行时就会因为userDao中使用到sessionFactory对象无法正常创建的而出错,这样执行Maven install命令编译项目时就会失败!
*
*/
ApplicationContext ac = new ClassPathXmlApplicationContext(new String[]{"spring.xml","spring-hibernate.xml"});
//从Spring的IOC容器中获取bean对象
UserServiceI userService = (UserServiceI) ac.getBean("userService");
//执行测试方法
userService.test();
}
}
每次执行【Maven install】命令时都会执行Junit单元测试中的代码有时候感觉挺累赘的,有时候往往就是因为一些单元测试中的代码导致【Maven install】命令编译项目失败!
将编译好的项目部署到tomcat服务器中运行,输入地址:http://localhost:8080/SSHE/strust2Test!saveUser.action进行访问,如下所示:
访问action的过程中没有出现错误,并且后台也没有报错并且打印出了Hibernate执行插入操作时的SQL语句,如下所示:
这说明三大框架整合开发的测试通过了。以上就是使用使用Maven搭建Struts2+Spring3+Hibernate4的整合开发环境的全部内容。