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

最新推荐文章于 2021-02-11 10:24:07 发布

dht91597

最新推荐文章于 2021-02-11 10:24:07 发布

阅读量659

点赞数

文章标签： json 数据库开发工具

原文链接：http://www.cnblogs.com/cxxjohnson/p/7476327.html

版权

分类：

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>