Struts2+Spring3+MyBatis3整合以及Spring注解开发 / 憋错料

分类：

Web（2）

最近在做一个SpringMVC+spring+MyBatis的项目，突然想起以前自己要搭建一个Struts2+Spring+IBatis的框架，但是没成功，正好看见培训时候老师给的千里之行的开源项目。于是将这个项目提供的SQL加入到了自己的数据库中（所以数据和项目名用的是qlzx），打算以后做练习的时候用这个数据库。那么接下来问题来了（不要说某翔或者不约，不是那个问题）：我有了数据库和数据，想要搭建一个网站，该怎么做？

1、环境

IDE	Eclipse Kepler(4.3.1)
Server	Tomcat 6.0
Struts	2.2.3.1
Spring	3.0.6
MyBatis	3.0.6
Database	MySQL 5.5
DB驱动	mysql-connector-Java-5.1.27
测试工具	JUnit 4 (Eclipse自带)

特别说明：因为Struts2在13年爆出了一个严重的安全漏洞，导致黑客可能获取网站最高权限(相关消息：http://news.mydrivers.com/1/269/269596.htm，http://it.sohu.com/20130718/n381990046.shtml)，所以真实建站时需要将Struts2升级至2.3.15.1或以上版本。这里因为是demo，所以仍然使用2.2.3.1。

2、需要的包

3、开发步骤

项目结构：

路径	功能	说明
action.base	包下的Action类为其他Action类的BaseAction，继承ActionSupport。	这个类中提供一些其他Action中的通用的方法。如果有这个类存在，那么其他Action类应该继承此包下的BaseAction。
action	存放所有Action类的包	如果没有写BaseAction的话则应该继承ActionSupport，否则此包下的所有类都应该继承BaseAction。 bean包为存放Java实体类的包。
dao.basedao	规定其他所有dao类的方法。	此包下的类应该为接口。
dao	dao的接口	因为使用MyBatis，所以不提供实现类。此包中的接口应该继承BaseDao。其中的方法名必须要和MyBatisMapper文件中的id大小写一致
service	服务层的接口。
service.impl	服务层的实现类。
utils	工具包。
conf	文件夹，存放基本配置。
comf.mapper	文件夹，存放mybatis的配置文件。

配置文件：

db.properties:

spy.properties

[plain] view plain copy

module.log=com.p6spy.engine.logging.P6LogFactory
#module.outage=com.p6spy.engine.outage.P6OutageFactory
# the mysql open source driver
#realdriver=com.mysql.jdbc.Driver
realdriver= com.mysql.jdbc.Driver
#the DriverManager class sequentially tries every driver that is
#registered to find the right driver. In some instances, it‘s possible to
#load up the realdriver before the p6spy driver, in which case your connections
#will not get wrapped as the realdriver will "steal" the connection before
#p6spy sees it. Set the following property to "true" to cause p6spy to
#explicitily deregister the realdrivers
deregisterdrivers=true
# outagedetection=true|false
# outagedetectioninterval=integer time (seconds)
#
outagedetection=false
# filter what is logged
filter=false
# turn on tracing
autoflush = true
# sets the date format using Java‘s SimpleDateFormat routine
dateformat=yyyy-MM-dd HH:mm:ss:SS
#list of categories to explicitly include
includecategories=error,statement
#list of categories to exclude: error, info, batch, debug, statement,
#commit, rollback and result are valid values
excludecategories=info,debug,result,batch,resultset,commit
# prints a stack trace for every statement logged
stacktrace=false
# if stacktrace=true, specifies the stack trace to print
stacktraceclass=
# determines if property file should be reloaded
reloadproperties=false
# determines how often should be reloaded in seconds
reloadpropertiesinterval=60
#if=true then url must be prefixed with p6spy:
useprefix=false
#specifies the appender to use for logging
appender=com.p6spy.engine.logging.appender.StdoutLogger
append=true
#The following are for log4j logging only
log4j.appender.STDOUT=org.apache.log4j.ConsoleAppender
log4j.appender.STDOUT.layout=org.apache.log4j.PatternLayout
log4j.appender.STDOUT.layout.ConversionPattern=p6spy - %m%n
log4j.logger.p6spy=INFO,STDOUT

这里使用到了一个包，叫p6spy.jar。

P6Spy 是针对数据库访问操作的动态监测框架（为开源项目，项目首页：www.p6spy.com）它使得数据库数据可无缝截取和操纵，而不必对现有应用程序的代码作任何修改。P6Spy 分发包包括P6Log，它是一个可记录任何 Java 应用程序的所有JDBC事务的应用程序。其配置完成使用时，可以进行数据访问性能的监测。

我们最需要的功能，查看sql语句，不是预编译的带问号的哦，而是真正的数据库执行的sql，更直观，更简单。

这个包主要用于调试sql，很方便。

web.xml:

[html] view plain copy

<?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_2_5.xsd" id="WebApp_ID" version="2.5">
<display-name>qlzx</display-name>
<welcome-file-list>
<welcome-file>index.jsp</welcome-file>
</welcome-file-list>
<filter>
<filter-name>struts2</filter-name>
<filter-class>
org.apache.struts2.dispatcher.ng.filter.StrutsPrepareAndExecuteFilter
</filter-class>
<init-param>
<param-name>config</param-name>
<param-value>struts-default.xml,struts-plugin.xml,struts.xml</param-value>
</init-param>
</filter>
<filter-mapping>
<filter-name>struts2</filter-name>
<url-pattern>/*</url-pattern>
</filter-mapping>
<context-param>
<param-name>contextConfigLocation</param-name>
<param-value>classpath:applicationContext.xml</param-value>
</context-param>
<filter>
<filter-name>encodingFilter</filter-name>
<filter-class>org.springframework.web.filter.CharacterEncodingFilter</filter-class>
<init-param>
<param-name>encoding</param-name>
<param-value>utf-8</param-value>
</init-param>
</filter>
<filter-mapping>
<filter-name>encodingFilter</filter-name>
<url-pattern>/*</url-pattern>
</filter-mapping>
<listener>
<listener-class>org.springframework.web.util.IntrospectorCleanupListener</listener-class>
</listener>
<listener>
<listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
</listener>
<error-page>
<error-code>500</error-code>
<location>/commons/error.jsp</location>
</error-page>
<error-page>
<error-code>404</error-code>
<location>/commons/404.jsp</location>
</error-page>
<error-page>
<error-code>403</error-code>
<location>/commons/403.jsp</location>
</error-page>
</web-app>

applicationContext.xml

[html] view plain copy

<?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">
<import resource="datasource.xml" />
<context:annotation-config/>
<context:component-scan base-package="com.qlzx"></context:component-scan>
<bean id="sqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean">
<property name="dataSource" ref="dataSource" />
<property name="configLocation" value="classpath:conf/MapperConfig.xml" />
</bean>
<!-- <bean id="userMapper" class="org.mybatis.spring.mapper.MapperFactoryBean">
<property name="sqlSessionFactory" ref="sqlSessionFactory"/> <property name="mapperInterface"
value="org.ko.webservice.dao.UserMapper"/> </bean> -->
<bean class="org.mybatis.spring.mapper.MapperScannerConfigurer">
<property name="basePackage" value="com.qlzx" />
<property name="sqlSessionFactory" ref="sqlSessionFactory" />
<property name="annotationClass" value="org.springframework.stereotype.Component" />
</bean>
<!-- bean class="org.mybatis.spring.annotation.MapperScannerPostProcessor">
<property name="basePackage" value="org.ko.webservice.dao" /> </bean -->
<bean id="transactionManager"
class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
<property name="dataSource">
<ref bean="dataSource" />
</property>
</bean>
<bean id="transactionInterceptor"
class="org.springframework.transaction.interceptor.TransactionInterceptor">
<property name="transactionManager" ref="transactionManager" />
<property name="transactionAttributes">
<props>
<prop key="add*">PROPAGATION_REQUIRED,-Exception</prop>
<prop key="insert*">PROPAGATION_REQUIRED,-Exception</prop>
<prop key="save*">PROPAGATION_REQUIRED,-Exception</prop>
<prop key="modify*">PROPAGATION_REQUIRED,-Exception</prop>
<prop key="update*">PROPAGATION_REQUIRED,-Exception</prop>
<prop key="del*">PROPAGATION_REQUIRED,-Exception</prop>
<prop key="delete*">PROPAGATION_REQUIRED,-Exception</prop>
<prop key="remove*">PROPAGATION_REQUIRED,-Exception</prop>
<prop key="query*">PROPAGATION_REQUIRED, readOnly,-Exception</prop>
<prop key="search*">PROPAGATION_REQUIRED, readOnly,-Exception</prop>
<prop key="select*">PROPAGATION_REQUIRED, readOnly,-Exception</prop>
<prop key="get*">PROPAGATION_REQUIRED, readOnly,-Exception</prop>
<prop key="load*">PROPAGATION_REQUIRED, -Exception</prop>
<prop key="*">readOnly</prop>
</props>
</property>
</bean>
<bean id="trasactionMethodPointcutAdvisor"
class="org.springframework.aop.support.NameMatchMethodPointcutAdvisor">
<property name="mappedNames">
<list>
<value>*</value>
</list>
</property>
<property name="advice">
<ref local="transactionInterceptor" />
</property>
</bean>
<bean id="ServiceAutoProxyCreator"
class="org.springframework.aop.framework.autoproxy.BeanNameAutoProxyCreator">
<property name="proxyTargetClass" value="true"></property>
<property name="beanNames">
<list>
<value>*Service*</value>
</list>
</property>
<property name="interceptorNames">
<list>
<value>trasactionMethodPointcutAdvisor</value>
</list>
</property>
</bean>
</beans>

其中最开始的两段：

<context:annotation-config/>

<context:component-scanbase-package="com.qlzx"></context:component-scan>

这两段是告诉Spring使用注解配置，扫描哪个包下的类中的注解。我这里的项目使用到了注解，所以必须要写这两句。同时，如果需要Struts2和MyBaties支持的话，那么就必须用到两个包：mybaties-spring-1.0.0.jar和struts2-spring-plugin.jar。

mybatis-spring-1.x.x.jar用于将mybatis无缝整合到Spring中。使用这个包需要用到java5+以及Spring3.0+的版本。版本的对应关系如下图：

根据这张表，因为我的MyBatis版本为3.0.6，所以使用mybatis-spring-1.0.2.jar

关于mybatis-spring.jar的简介、使用、以及API等更多信息，请参阅官网：http://mybatis.github.io/spring/zh/index.html

至于struts2-spring-plugin.jar不多说了，这个是用于整个Struts2和Spring的，这个包在Struts2的包中应该是有的，没有的话那就随便去网上下一个吧。

datasource.xml

[html] view plain copy

<?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">
<bean id="configurer"
class="org.springframework.beans.factory.config.PropertyPlaceholderConfigurer">
<property name="location">
<value>classpath:conf/db.properties</value>
</property>
</bean>
<bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource"
destroy-method="close">
<property name="driverClass">
<value>com.p6spy.engine.spy.P6SpyDriver</value>
</property>
<property name="jdbcUrl">
<value>${jdbc.url}</value>
</property>
<property name="user">
<value>${jdbc.username}</value>
</property>
<property name="password">
<value>${jdbc.password}</value>
</property>
<property name="minPoolSize">
<value>2</value>
</property>
<property name="maxPoolSize">
<value>15</value>
</property>
<property name="initialPoolSize">
<value>2</value>
</property>
<property name="maxIdleTime">
<value>1800</value>
</property>
<property name="acquireIncrement">
<value>2</value>
</property>
<!--JDBC的标准参数，用以控制数据源内加载的PreparedStatements数量。但由于预缓存的statements 属于单个connection而不是整个连接池。所以设置这个参数需要考虑到多方面的因素。
如果maxStatements与maxStatementsPerConnection均为0，则缓存被关闭。Default: 0 -->
<property name="maxStatements">
<value>0</value>
</property>
<property name="idleConnectionTestPeriod">
<value>0</value>
</property>
<property name="acquireRetryAttempts">
<value>30</value>
</property>
<!--获取连接失败将会引起所有等待连接池来获取连接的线程抛出异常。但是数据源仍有效保留，并在下次调用getConnection()的时候继续尝试获取连接。如果设为true，那么在尝试
获取连接失败后该数据源将申明已断开并永久关闭。Default: false -->
<property name="breakAfterAcquireFailure">
<value>false</value>
</property>
<!--因性能消耗大请只在需要的时候使用它。如果设为true那么在每个connection提交的时候都将校验其有效性。建议使用idleConnectionTestPeriod或automaticTestTable
等方法来提升连接测试的性能。Default: false -->
<property name="testConnectionOnCheckout">
<value>false</value>
</property>
<property name="debugUnreturnedConnectionStackTraces">
<value>false</value>
</property>
<property name="acquireRetryDelay">
<value>100</value>
</property>
</bean>
</beans>

这个xml因为有注释，一看即明，不再赘述。使用到了c3p0连接池，所以记得引入c3p0.jar

datasource.xml和applicationContext.xml两个XML中有一个需要注意的细节就是：其中所有标签的属性，键和值之间不能有空格或者换行存在。如以下三种情况是错误的:

[html] view plain copy

<value>false </value>

[html] view plain copy

<value>false
</value>

[html] view plain copy

<property name = "acquireRetryDelay">

空格不容易被发现，但是却影响程序运行，所以平时要养成良好的习惯。

struts.xml

[html] view plain copy

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE struts PUBLIC "-//Apache Software Foundation//DTD Struts Configuration 2.1//EN" "http://struts.apache.org/dtds/struts-2.1.dtd">
<struts>
<constant name="struts.i18n.encoding" value="UTF-8" />
<constant name="struts.action.extension" value="action,do,htm" />
<constant name="struts.configuration.xml.reload" value="true" />
<constant name="struts.devMode" value="true" />
<constant name="struts.serve.static.browserCache" value="false" />
<constant name="struts.objectFactory" value="spring" />
<constant name="struts.enable.DynamicMethodInvocation" value="false" />
</struts>

这个唯一要说的就是，因为项目使用注解配置Action，所以这里就不再配置Action。

MapperConfig.xml

[html] view plain copy

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE configuration PUBLIC "-//mybatis.org//DTD Config 3.0//EN" "http://mybatis.org/dtd/mybatis-3-config.dtd" >
<configuration>
<mappers>
<mapper resource="conf/mapper/PublicMapper.xml" />
</mappers>
</configuration>

这个文件的作用就是引入其他的Mabits的xml配置文件，如果写多个的话在这里添加即可。

PublicMapper.xml

[html] view plain copy

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd" >
<mapper namespace="com.qlzx.dao.UserDao">
<resultMap id="userlist" type="com.qlzx.bean.Users">
<id column="id" property="id" />
<result column="USERNAME" property="userName" />
<result column="USERPWD" property="userPwd" />
</resultMap>
<select id="selectUsers" parameterType="java.util.Map"
resultMap="userlist">
select ID,USERNAME,USERPWD from USERINFO where 1=1
<if test="action == ‘login‘">
<if test="userName != null and userPwd != ‘‘">
and USERNAME = #{userName}
and USERPWD = #{password}
</if>
</if>
</select>
<select id="selectByMap" resultType="java.util.HashMap"
parameterType="java.util.Map">
</select>
</mapper>

这个文件也没什么好说的。mapper标签里的namespace是指向Dao的。resultMap是告诉MyBatis查出来的结果和bean的对应关系。具体用法在网上有一大堆，不再赘述。

我在这里接收的参数全都是HashMap。因为这样可以比较灵活。在select中的if中的判断条件，其中acton是存在参数集合中的key，意思是如果传来的参数中有一个action的key并且其value为login的话，那么sql中就添加if中的那些，如果没有的话那么就只执行外面那个。这样做的好处是，如果是登陆的话，那么在参数map中可以放三个键值对，分别是action、userName、password。如果我需要查询所有用户的集合的话，那么只需要穿一个空的参数集合即可（能不能穿null还未测试）。

另外还有一点要说的就是，resultMap。这里的resultMap是上面定义好的resultMap,值和上面定义的resultMap的id对应。如果是具体的类型的话，那么需要将resultMap改成resultType。使用resultMap的结果自动为集合，哪怕只有一个前台也可以使用List来接收。

代码：

DAO层：

BaseDao:因为我这里有一个basedao，所以这里先贴出basedao的代码。

[java] view plain copy

package com.qlzx.dao.basedao;
import java.io.Serializable;
import java.util.List;
import org.apache.ibatis.annotations.Param;
public abstract interface BaseDao<T, E, PK extends Serializable>
{
public abstract int countByExample(E paramE);
public abstract List<T> query();
public abstract int deleteByExample(E paramE);
public abstract int deleteByPrimaryKey(PK paramPK);
public abstract int insert(T paramT);
public abstract int insertSelective(T paramT);
public abstract List<T> selectByExample(E paramE);
public abstract T selectByPrimaryKey(PK paramPK);
public abstract int updateByExampleSelective(@Param("record") T paramT, @Param("example") E paramE);
public abstract int updateByExample(@Param("record") T paramT, @Param("example") E paramE);
public abstract int updateByPrimaryKeySelective(T paramT);
public abstract int updateByPrimaryKey(T paramT);
public abstract List<T> selectByExampleWithBLOBs(E paramE);
public abstract int updateByPrimaryKeyWithBLOBs(T paramT);
}

UserDao

[java] view plain copy

package com.qlzx.dao;
import java.math.BigDecimal;
import java.util.List;
import java.util.Map;
import org.springframework.stereotype.Repository;
import com.qlzx.bean.Users;
import com.qlzx.dao.basedao.BaseDao;
@Repository
public interface UserDao extends BaseDao<Users, Map<String,?>, BigDecimal> {
public abstract List<Users> selectUsers(Map<String ,?> paramMap);
public abstract int insert (Map<String,?>paramMap);
public abstract int delete(Map<String,?> paramMap);
public abstract int updateByMap(Map<String,?> paramMap);
}

注意这个Dao只是一个接口。前面说过，因为具体的查询已经在xml中配置了，所以这个接口不需要写实现类，直接调用方法即可。这个dao的包名和xml中的namespace对应，方法名和对应xml中的id对应，包括大小写。

Service：

UserService

[java] view plain copy

package com.qlzx.service;
import java.util.List;
import java.util.Map;
import com.qlzx.bean.Users;
public abstract class UserService {
public abstract List<Users> selectUsers(Map<String ,?> paramMap);
public abstract int insert (Map<String,?>paramMap);
public abstract int delete(Map<String,?> paramMap);
public abstract int updateByMap(Map<String,?> paramMap);
}

Service接口，不需要多讲。

UserServiceImpl:

[java] view plain copy

package com.qlzx.service.impl;
import java.util.List;
import java.util.Map;
import javax.annotation.Resource;
import org.springframework.stereotype.Service;
import com.qlzx.bean.Users;
import com.qlzx.dao.UserDao;
import com.qlzx.service.UserService;
@Service
public class UserServiceImpl extends UserService {
@Resource
public UserDao dao;
public void setDao(UserDao dao) {
this.dao = dao;
}
@Override
public List<Users> selectUsers(Map<String, ?> paramMap) {
return dao.selectUsers(paramMap);
}
@Override
public int insert(Map<String, ?> paramMap) {
return 0;
}
@Override
public int delete(Map<String, ?> paramMap) {
return 0;
}
@Override
public int updateByMap(Map<String, ?> paramMap) {
return 0;
}
}

Service实现类，同样不需要多讲。

BaseAction

[java] view plain copy

package com.qlzx.action.base;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import org.apache.struts2.interceptor.ServletRequestAware;
import org.apache.struts2.interceptor.ServletResponseAware;
import com.opensymphony.xwork2.ActionSupport;
public class BaseAction extends ActionSupport implements ServletRequestAware,
ServletResponseAware {
private static final long serialVersionUID = 7079198825973108720L;
protected HttpServletRequest request;
protected HttpServletResponse response;
@Override
public void setServletResponse(HttpServletResponse response) {
this.response = response;
}
@Override
public void setServletRequest(HttpServletRequest request) {
this.request = request;
}
}

这个类要说明的是除了继承ActionSupport以外，还实现了两个接口：ServletRequestAware,ServletResponseAware 。这两个接口用于IOC自动注入HttpServletRequest和HttpServletResponse。因为Action中可能对Session、Response和Request进行操作，所以在BaseAction中实现了这两个接口。获取Session、Request和Response除了这个方法以外还可以通过ActionContext获得。

PublicController：

[java] view plain copy

package com.qlzx.action;
import java.awt.image.BufferedImage;
import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import javax.annotation.Resource;
import javax.servlet.http.HttpServletResponse;
import javax.servlet.http.HttpSession;
import net.sf.json.JSONArray;
import org.apache.struts2.convention.annotation.Action;
import org.apache.struts2.convention.annotation.ParentPackage;
import org.apache.struts2.convention.annotation.Result;
import org.springframework.stereotype.Controller;
import com.opensymphony.xwork2.ActionContext;
import com.qlzx.action.base.BaseAction;
import com.qlzx.bean.Users;
import com.qlzx.service.UserService;
import com.qlzx.utils.RandomPic;
import com.qlzx.utils.Util;
import com.sun.image.codec.jpeg.ImageFormatException;
import com.sun.image.codec.jpeg.JPEGCodec;
import com.sun.image.codec.jpeg.JPEGImageEncoder;
@Controller
@ParentPackage(value="json-default")
public class PublicController extends BaseAction {
private static final long serialVersionUID = -1941557452311902440L;
@Resource
UserService userService;
private String userName;
private String password;
private String formid;
private String resultJson;
private String code;
private ByteArrayInputStream imageStream;
@Action(value = "login", results = {
@Result(name = "success", location = "/message.jsp") ,
@Result(name = "failed",type="json",params={"root","resultJson"})
})
public String login() {
Map<String,Object> paramMap = new HashMap<String,Object>();
Map<String, ?> session = (Map<String, ?>) ActionContext.getContext()
.getSession();
String formid = (String) session.get("formid");
if (null != formid && this.formid.equals(formid)) {
resultJson="请勿重复提交";
return "failed";
}
if(!session.get("code").toString().equals(this.code)){
resultJson = "验证码错误";
return "failed";
}
paramMap.put("action", "login");
paramMap.put("userName", userName);
paramMap.put("password", password);
List<Users> user = userService.selectUsers(paramMap);
if (user != null && user.size()>0) {
String sessionid = Util.getToken();
resultJson = "登陆成功";
HttpSession cession = request.getSession(true);
cession.setAttribute("user", user.get(0));
cession.setAttribute("sessionId",sessionid);
return "success";
} else {
resultJson = "用户名或密码错误";
return "failed";
}
}
@Action(value = "alluser", results = {
@Result(name = "success",type="json",params={"root","resultJson"})
})
public String allUsers() throws IOException {
Map<String, String> paramMap = new HashMap<String, String>();
List<Users> userList = userService.selectUsers(paramMap);
// 将要被返回到客户端的对象
// 如果是List类型则使用JsonArray，如果是其他对象类型则使用jsonObject
JSONArray array = new JSONArray();
array.addAll(userList);
this.resultJson = array.toString();
return "success";
}
@Action(value = "logout", results = { @Result(name = "success", location = "/index.jsp") })
public String logout(){
Map<String, ?> session = (Map<String, ?>) ActionContext.getContext()
.getSession();
session.clear();
return "success";
}
@Action(value = "validateCode", results = {
@Result(name = "success",type="stream",params={"contentType","image/jpeg","inputName","imageStream"})
})
public String validateCode() {
RandomPic pic = new RandomPic();
BufferedImage image = pic.validatePic();
String code = pic.getCode();
System.out.println(code);
ActionContext.getContext().getSession().put("code", code);
imageStream = convertImageToStream(image);
return "success";
}
/**
* 将BufferedImage转换成ByteArrayInputStream
* @param image 图片
* @return ByteArrayInputStream 流
*/
private static ByteArrayInputStream convertImageToStream(BufferedImage image) {
ByteArrayInputStream inputStream = null;
ByteArrayOutputStream bos = new ByteArrayOutputStream();
JPEGImageEncoder jpeg = JPEGCodec.createJPEGEncoder(bos);
try {
jpeg.encode(image);
byte[] bts = bos.toByteArray();
inputStream = new ByteArrayInputStream(bts);
} catch (ImageFormatException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
}
return inputStream;
}
@Action(value = "formid", results = {
@Result(name = "success",type="json",params={"root","resultJson"})
})
public String formid() {
resultJson = Util.getToken();
return "success";
}
public void setService(UserService service) {
this.userService = service;
}
public void setResponse(HttpServletResponse response) {
this.response = response;
}
public void setUserName(String userName) {
this.userName = userName;
}
public void setPassword(String password) {
this.password = password;
}
public void setFormid(String formid) {
this.formid = formid;
}
public String getResultJson() {
return resultJson;
}
public ByteArrayInputStream getImageStream() {
return imageStream;
}
public void setCode(String code) {
this.code = code;
}
}

首先要说的是，因为要返回Json，所以我使用了JsonObject。要使用这个家伙除了代表他自己的json-lib外，还有6个包是必须的，列表如下：

JsonObject可以很方便的将Java对象转换为Json字符串。使用过程中有一点需要注意，那就是如果这个java对象是个集合，那么就要使用JsonArray类，简单的使用方法在allusers这个方法里已经有写。如果是java非集合对象的话，那么就使用JsonOject类。

另外，不要因为使用注解配置Action就以为那些属性可以使用通过@Autoware或者@Resource注解自动注入。经过我亲测这种方法是不行的。我想因为前台页面无法沟通到Spring的原因吧。所以这些属性必须要手动写setter和getter。

关于配置Action，因为使用到注解配置，所以一会儿说到注解的时候一起记录。

工具类

Util

[java] view plain copy

package com.qlzx.utils;
import java.security.MessageDigest;
import java.util.Random;
import sun.misc.BASE64Encoder;
public class Util {
public static String getToken(){
String token = System.currentTimeMillis()+new Random().nextInt()+"";
try {
MessageDigest md = MessageDigest.getInstance("MD5");
byte[] md5 = md.digest(token.getBytes());
BASE64Encoder encoder = new BASE64Encoder();
return encoder.encode(md5);
} catch (Exception e) {
throw new RuntimeException(e);
}
}
}

这个类只有一个方法，就是生成一个唯一的Token，这个Token可以用在表单号、sessionid等地方、甚至改写一下可以为密码加密。

RandomPic

[java] view plain copy

package com.qlzx.utils;
import java.awt.Color;
import java.awt.Font;
import java.awt.Graphics;
import java.awt.Graphics2D;
import java.awt.image.BufferedImage;
import java.util.Random;
/**
* 产生随机图片
* @author Administrator
*
*/
public class RandomPic{
private static final long serialVersionUID = 1L;
public static final int WIDTH = 120; //图片的宽
public static final int HEIGHT = 45; //图片高
private String code = "";
public BufferedImage validatePic() {
//创建一个图像
BufferedImage image = new BufferedImage(WIDTH,HEIGHT,BufferedImage.TYPE_INT_RGB);
//获取图像
Graphics g = image.getGraphics();
//1.设置背景色
setBackground(g);
//2.设置边框
setBorder(g);
//3.画干扰线
drawRandomLine(g);
//4、生成并画随机验证码
drawRandomNum((Graphics2D)g);
return image;
}
private void drawRandomLine(Graphics g) {
g.setColor(Color.GREEN);
//画至少6条干扰线
int k = 0;
while (k < 1){
k = new Random().nextInt(6);
}
for (int i = 0; i < k; i++) {
//生成干扰线随机起始坐标
int x1 = new Random().nextInt(WIDTH);
int y1 = new Random().nextInt(HEIGHT);
//生成干扰线随机结束坐标
int x2 = new Random().nextInt(WIDTH);
int y2 = new Random().nextInt(HEIGHT);
//画干扰线
g.drawLine(x1, y1, x2, y2);
}
}
/**
* 写随机汉字。因为 <code> Graphics</code> 没有旋转的方法。但默认生成的 <code>Graphics2D</code> 中有旋转的方法
* 所以在传参时将参数类型强转成 <code>Graphics2D</code>
* (<code>BufferedImage.getGraphics()</code>方法返回的其实就是<code>Graphics2DGraphics2D</code>)。
* @param g
*/
private void drawRandomNum(Graphics2D g) {
code = "";
g.setColor(Color.RED);
g.setFont(new Font("微软雅黑",Font.BOLD,20));
//常用汉字
String base = "\u96d5\u864e\u7684\u4e00\u4e86\u662f\u6211\u4e0d\u5728\u4eba\u4eec\u6709\u6765\u4ed6\u8fd9\u4e0a\u7740\u4e2a\u5730\u5230\u5927\u91cc\u8bf4\u5c31\u53bb\u5b50\u5f97\u4e5f\u548c\u90a3\u8981\u4e0b\u770b\u5929\u65f6\u8fc7\u51fa\u5c0f\u4e48\u8d77\u4f60\u90fd\u628a\u597d\u8fd8\u591a\u6ca1\u4e3a\u53c8\u53ef\u5bb6\u5b66\u53ea\u4ee5\u4e3b\u4f1a\u6837\u5e74\u60f3\u751f\u540c\u8001\u4e2d\u5341\u4ece\u81ea\u9762\u524d\u5934\u9053\u5b83\u540e\u7136\u8d70\u5f88\u50cf\u89c1\u4e24\u7528\u5979\u56fd\u52a8\u8fdb\u6210\u56de\u4ec0\u8fb9\u4f5c\u5bf9\u5f00\u800c\u5df1\u4e9b\u73b0\u5c71\u6c11\u5019\u7ecf\u53d1\u5de5\u5411\u4e8b\u547d\u7ed9\u957f\u6c34\u51e0\u4e49\u4e09\u58f0\u4e8e\u9ad8\u624b\u77e5\u7406\u773c\u5fd7\u70b9\u5fc3\u6218\u4e8c\u95ee\u4f46\u8eab\u65b9\u5b9e\u5403\u505a\u53eb\u5f53\u4f4f\u542c\u9769\u6253\u5462\u771f\u5168\u624d\u56db\u5df2\u6240\u654c\u4e4b\u6700\u5149\u4ea7\u60c5\u8def\u5206\u603b\u6761\u767d\u8bdd\u4e1c\u5e2d\u6b21\u4eb2\u5982\u88ab\u82b1\u53e3\u653e\u513f\u5e38\u6c14\u9ec4\u4e94\u7b2c\u4f7f\u5199\u519b\u6728\u73cd\u5427\u6587\u8fd0\u518d\u679c\u600e\u5b9a\u8bb8\u5feb\u660e\u884c\u56e0\u522b\u98de\u5916\u6811\u7269\u6d3b\u90e8\u95e8\u65e0\u5f80\u8239\u671b\u65b0\u5e26\u961f\u5148\u529b\u5b8c\u5374\u7ad9\u4ee3\u5458\u673a\u66f4\u4e5d\u60a8\u6bcf\u98ce\u7ea7\u8ddf\u7b11\u554a\u5b69\u4e07\u5c11\u76f4\u610f\u591c\u6bd4\u9636\u8fde\u8f66\u91cd\u4fbf\u6597\u9a6c\u54ea\u5316\u592a\u6307\u53d8\u793e\u4f3c\u58eb\u8005\u5e72\u77f3\u6ee1\u6885\u65e5\u51b3\u767e\u539f\u62ff\u7fa4\u7a76\u5404\u516d\u672c\u601d\u89e3\u7acb\u6cb3\u6751\u516b\u96be\u65e9\u8bba\u5417\u6839\u5171\u8ba9\u76f8\u7814\u4eca\u5176\u4e66\u5750\u63a5\u5e94\u5173\u4fe1\u89c9\u6b65\u53cd\u5904\u8bb0\u5c06\u5343\u627e\u4e89\u9886\u6216\u5e08\u7ed3\u5757\u8dd1\u8c01\u8349\u8d8a\u5b57\u52a0\u811a\u7d27\u7231\u7b49\u4e60\u9635\u6015\u6708\u9752\u534a\u706b\u6cd5\u9898\u5efa\u8d76\u4f4d\u5531\u6d77\u4e03\u5973\u4efb\u4ef6\u611f\u51c6\u5f20\u56e2\u5c4b\u79bb\u8272\u8138\u7247\u79d1\u5012\u775b\u5229\u4e16\u521a\u4e14\u7531\u9001\u5207\u661f\u5bfc\u665a\u8868\u591f\u6574\u8ba4\u54cd\u96ea\u6d41\u672a\u573a\u8be5\u5e76\u5e95\u6df1\u523b\u5e73\u4f1f\u5fd9\u63d0\u786e\u8fd1\u4eae\u8f7b\u8bb2\u519c\u53e4\u9ed1\u544a\u754c\u62c9\u540d\u5440\u571f\u6e05\u9633\u7167\u529e\u53f2\u6539\u5386\u8f6c\u753b\u9020\u5634\u6b64\u6cbb\u5317\u5fc5\u670d\u96e8\u7a7f\u5185\u8bc6\u9a8c\u4f20\u4e1a\u83dc\u722c\u7761\u5174\u5f62\u91cf\u54b1\u89c2\u82e6\u4f53\u4f17\u901a\u51b2\u5408\u7834\u53cb\u5ea6\u672f\u996d\u516c\u65c1\u623f\u6781\u5357\u67aa\u8bfb\u6c99\u5c81\u7ebf\u91ce\u575a\u7a7a\u6536\u7b97\u81f3\u653f\u57ce\u52b3\u843d\u94b1\u7279\u56f4\u5f1f\u80dc\u6559\u70ed\u5c55\u5305\u6b4c\u7c7b\u6e10\u5f3a\u6570\u4e61\u547c\u97f3\u7b54\u54e5\u9645\u65e7\u795e\u5ea7\u7ae0\u5e2e\u5566\u53d7\u7cfb\u4ee4\u8df3\u975e\u4f55\u725b\u53d6\u5165\u5cb8\u6562\u6389\u5ffd\u79cd\u88c5\u9876\u6025\u6234\u6797\u505c\u606f\u53e5\u533a\u8863\u822c\u62a5\u53f6\u538b\u6162\u53d4\u80cc\u7ec6\u8273\u4f50";
//写四个汉字
for (int i = 0; i < 4; i++) {
//在字符串范围内取一个汉字
String ch = base.charAt(new Random().nextInt(base.length()))+"";
//将生成的汉字添加到变量中
code = code+ch;
//写字的X坐标
int x = i*30+3;
//旋转30度以内
//因为也要向左旋转，所以先生成一个随机数后再模30即可
int degree = new Random().nextInt() % 30;
//旋转的弧度
double theta = degree*Math.PI/180;
//旋转
g.rotate(theta, x, 30);
//写字
g.drawString(ch, x, 30);
//将弧度转回去
g.rotate(-theta, x, 30);
}
}
private void setBorder(Graphics g) {
g.setColor(Color.BLUE);
g.drawRect(0, 0, WIDTH - 2, HEIGHT - 2);
}
private void setBackground(Graphics g) {
g.setColor(Color.WHITE);
g.fillRect(0, 0, WIDTH, HEIGHT);
}
public String getCode() {
return code;
}
}

这个类用于生成一个汉字验证码。代码很简单，一看就懂，要说明的是，因为每次生成的验证码不一样，所以没有将此类中的变量写成static，因此对应的方法也就不是static的。使用此类生成验证码的时候需要先创建对象。另外，汉字列表可以写在properties文件中，使用静态代码块加载后使用。

注解。

首先，要使用注解，必须在spring的配置文件中写上这两句：

[html] view plain copy

<context:annotation-config/>
<context:component-scan base-package="com.qlzx"></context:component-scan>

这两句第一句的意思是使用注解配置。有了这句Spring注解才有用。第二句的意思是自动扫描，扫描的内容自然是注解了。里面有一个属性：base-package，这个属性用来告诉Spring扫描哪个包下的类。比如我的代码就是扫描com.qlzx包下的所有类，包括其中的子包。

然后就是Struts对注解的支持了，Struts2要实现对注解的支持，那就必须要使用到struts2-convention-plugin-2.x.x.jar。有了这个包，才能使Struts2支持注解。

对于注解，MVC三层有四种注解，分别是：@Component/@Repository/@Service/@Controller。

如果某个类的头上带有以上注解，就会将这个对象作为Bean注册进Spring容器。以上的4个注解，用法完全一摸一样，只有语义上的区别。

其中后三个注解是第一个注解@Component的细化。@Component在三层中都可以使用，而细化后，Dao层使用@Repository，Service层使用@Service，而Action使用@Controller。

按照网上的资料，说其中的@Component不推荐使用，至于为什么，还没想出来，大概是因为@Component范围太广容易出问题吧。而这几个注解都可以带参数，如：@Service("exampleService")或者@Service(value="exampleService")。使用注解后相当于在spring配置文件中添加了bean节点，而像上面这样带参数写的话相当于给bean添加了name属性。在我的代码中因为只有一个Action类、Service类、Dao类都各只有一个，所以没有写value。如果是有多个的话，必须在注解中写上value以示区分。

在spring中生成bean之后，就要定义那些属性需要自动注入了。使用自动注入有两个注解：@Resource和@Autowired。这两个注解作用一样，只不过 @Autowired 按 byType 自动注入，面@Resource 默认按 byName 自动注入罢了。@Autowired是自动寻找匹配类型，然后注入。@Resource 有两个属性是比较重要的，分别是 name 和 type，Spring 将@Resource注释的 name 属性解析为 Bean 的名字，而 type 属性则解析为 Bean 的类型。所以如果使用 name 属性，则使用 byName 的自动注入策略，而使用 type 属性时则使用 byType 自动注入策略。如果既不指定 name 也不指定 type 属性，这时将通过反射机制使用 byName 自动注入策略。这里的name就是上一段说的@Service(value="exampleService")中的exampleService部分。

如果在使用@Autowired注解注入的时候，需要特定的名称，那么可以使用@Qualifier注释指定需要注入那个bean。如：

[java] view plain copy

@Autowired
@Qualifier("userServiceImpl")
UserService userService;

这样在使用的时候Spring就会自动寻找所有标记注解的类中的UserServiceImpl这个类去注入。

注意：因为@AutoWired是按类型注入，所以参数只能是类型名。而因为bean中的name默认类型名首字母小写，所以这里也是首字母小写。

那么如果这样写行不行呢？

[java] view plain copy

@Resource
@Qualifier("userServiceImpl")
UserService userService;

行不行，我也不知道，我猜想应该是可以的，本人没有亲测。为什么？因为Eclipse没有报错 : P (开玩笑的)。

这里要提一下，@Resource注解需要使用到Spring中的common-annotations.jar，所以这个包记得引入。

需要了解以上几个注解的更多知识，参看网址：

http://blog.csdn.net/xyh820/article/details/7303330

（感谢xyh820和原作者）

三层的类都注解好了，接下来就是使用注解配置Action了。

要使用注解配置Struts2的Action，那么就必须引入一个包：struts2-convention-plugin.jar。我在这个项目中使用的是struts2-convention-plugin-2.2.3.1.jar

使用注解配置Action的时候，需要用到的最主要的注解为@Action。这个注解为配置Action时候必须用到的注解。

[java] view plain copy

@Action(value = "login", results = {
@Result(name = "success", location = "/message.jsp") ,
@Result(name = "failed",type="json",params={"root","resultJson"})
})
public String login() {}

以上这段代码是将login方法通过注解配置成一个名字叫login的action。如果这个方法返回的是success字符串，那么则跳转到message.jsp，如果返回的事failed字符串，则返回一个json。@Action是配置Action相关的信息。而@Result这个注解是配置这个Action返回的信息，其中的信息的含义对照一下下面的xml代码就能看出来。特别要说明的是params这个属性，他接受的是一个String类型的数组，写的形式是key、value、key、value这样的，例如下面：

[java] view plain copy

@Action(value = "validateCode", results = {
@Result(name = "success",type="stream",params={"contentType","image/jpeg","inputName","imageStream"})
})

这个是返回一个流，它相当于在struts2的配置文件中加入下面这段代码：

[html] view plain copy

<action name="validateCode" class="com.qlzx.action.PublicController" method="validateCode">
<result name="success" type="stream">
<param name="contentType">image/jpeg</param>
<param name="inputName">imageStream</param>
</result>
</action>

当然，因为返回了Json，所以只有上面那个注解是不行的，还需要在这个方法的类中加一个注解：

[java] view plain copy

@ParentPackage(value="json-default")
public class PublicController extends BaseAction {}

上面配置login的注解相当于在Struts中的配置文件写入了如下的代码：

[html] view plain copy

<package name="User" namespace="/" extends="struts-default,json-default">
<action name="login" class="com.qlzx.action.PublicController"
method="login">
<result name="success" type="redirect">/message.jsp</result>
<result name="failed" type="json">
<param name="root">resultJson</param>
</result>
</action>
</package>

其中@ParentPackage相当于配置中的extends这个属性。不过经过测试这个注解的value不能是多个值。

常用的注解配置如下：

1) @ParentPackage 指定父包，（不写默认 “struts-default”）

2) @Namespace 指定命名空间(不写默认为 “/”)

3) @Results 一组结果的数组(在只有多个处理结果的时候使用)

4)@Result(name="success",location="/msg.jsp") 一个结果的映射

5)@Action(value="login") 指定某个请求处理方法的请求URL。注意，它不能添加在Action类上，要添加到方法上。

6) @ExceptionMappings一级声明异常的数组

7) @ExceptionMapping映射一个声明异常

特别要说明的是：如果使用Struts的标注配置了Action后，那么视图层类上的@Controller这个标注可以不需要。

最后就是JSP页面了，代码这里省略。附上效果图。

index.jsp

执行的sql：

message.jsp

写在最后的话：

因为本人也是在学习过程当中，所以文章中难免出现什么错误之处。如果对这个文章有什么疑问或者某些地方有更好的方案或者错误的指正，欢迎留言一起讨论。

本文为原创，如果转载请注明出处：

http://blog.csdn.net/levelmini

时间： 2024-08-27 01:00:32

Struts2+Spring3+MyBatis3整合以及Spring注解开发

Struts2+Spring3+MyBatis3整合以及Spring注解开发的相关文章

Struts2+Spring3+Mybatis3开发环境搭建

Struts2+Spring3+Hibernate——整合byMaven

Struts2,Spring3,Hibernate4整合--SSH框架

struts2 + spring3 + mybatis3 环境搭建

Spring 注解开发和测试

Annotation（三）——Spring注解开发

spring注解开发中常用注解以及简单配置

spring注解开发及AOP

Spring注解开发系列 VIII --- SpringMVC