Spring 注解学习手札（一） 构建简单Web应用

我们将用到如下jar包：

引用

aopalliance-1.0.jar
commons-logging-1.1.1.jar
log4j-1.2.15.jar
spring-beans-2.5.6.jar
spring-context-2.5.6.jar
spring-context-support-2.5.6.jar
spring-core-2.5.6.jar
spring-tx-2.5.6.jar
spring-web-2.5.6.jar
spring-webmvc-2.5.6.jar

先看web.xml

 xmlversion="1.0"encoding="UTF-8"?>
 <web-app
 xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
 xmlns="http://java.sun.com/xml/ns/javaee"
 xmlns:web="http://java.sun.com/xml/ns/javaee/web-app_2_5.xsd"
 xsi:schemaLocation="http://java.sun.com/xml/ns/javaeehttp://java.sun.com/xml/ns/javaee/web-app_2_5.xsd"
 id="WebApp_ID"
 version="2.5">
 <display-name>springdisplay-name>

 <context-param>
 <param-name>webAppRootKeyparam-name>
 <param-value>spring.webapp.rootparam-value>
 context-param>

 <context-param>
 <param-name>log4jConfigLocationparam-name>
 <param-value>classpath:log4j.xmlparam-value>
 context-param>
 <context-param>
 <param-name>log4jRefreshIntervalparam-name>
 <param-value>60000param-value>
 context-param>

 <context-param>
 <param-name>contextConfigLocationparam-name>
 <param-value>/WEB-INF/applicationContext.xmlparam-value>
 context-param>

 <filter>
 <filter-name>CharacterEncodingFilterfilter-name>
 <filter-class>org.springframework.web.filter.CharacterEncodingFilterfilter-class>
 <init-param>
 <param-name>encodingparam-name>
 <param-value>UTF-8param-value>
 init-param>
 <init-param>
 <param-name>forceEncodingparam-name>
 <param-value>trueparam-value>
 init-param>
 filter>
 <filter-mapping>
 <filter-name>CharacterEncodingFilterfilter-name>
 <url-pattern>/*url-pattern>
 filter-mapping>

 <listener>
 <listener-class>org.springframework.web.context.ContextLoaderListenerlistener-class>
 listener>
 <listener>
 <listener-class>org.springframework.web.util.Log4jConfigListenerlistener-class>
 listener>

 <servlet>
 <servlet-name>springservlet-name>
 <servlet-class>org.springframework.web.servlet.DispatcherServletservlet-class>
 <init-param>
 <param-name>contextConfigLocationparam-name>
 <param-value>/WEB-INF/servlet.xmlparam-value>
 init-param>
 servlet>
 <servlet-mapping>
 <servlet-name>springservlet-name>
 <url-pattern>*.dourl-pattern>
 servlet-mapping>
 <welcome-file-list>
 <welcome-file>index.htmlwelcome-file>
 <welcome-file>index.htmwelcome-file>
 <welcome-file>index.jspwelcome-file>
 <welcome-file>default.htmlwelcome-file>
 <welcome-file>default.htmwelcome-file>
 <welcome-file>default.jspwelcome-file>
 welcome-file-list>
 web-app>

有不少人问我，这段代码是什么：

 <context-param>
 <param-name>webAppRootKeyparam-name>
 <param-value>spring.webapp.rootparam-value>
 context-param>

这是当前应用的路径变量，也就是说你可以在其他代码中使用${spring.webapp.root}指代当前应用路径。我经常用它来设置log的输出目录。
为什么要设置参数log4jConfigLocation？

 <context-param>
 <param-name>log4jConfigLocationparam-name>
 <param-value>classpath:log4j.xmlparam-value>
 context-param>
 <context-param>
 <param-name>log4jRefreshIntervalparam-name>
 <param-value>60000param-value>
 context-param>

这是一种基本配置，spring中很多代码使用了不同的日志接口，既有log4j也有commons-logging，这里只是强制转换为log4j！并且，log4j的配置文件只能放在classpath根路径。同时，需要通过commons-logging配置将日志控制权转交给log4j。同时commons-logging.properties必须放置在classpath根路径。
commons-logging内容：

 org.apache.commons.logging.Log=org.apache.commons.logging.impl.Log4JLogger

最后，记得配置log4j的监听器：

 <listener>
 <listener-class>org.springframework.web.util.Log4jConfigListenerlistener-class>
 listener>

接下来，我们需要配置两套配置文件，applicationContext.xml和servlet.xml。
applicationContext.xml用于对应用层面做整体控制。按照分层思想，统领service层和dao层。servlet.xml则单纯控制controller层。

 xmlversion="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/beanshttp://www.springframework.org/schema/beans/spring-beans.xsd
 http://www.springframework.org/schema/contexthttp://www.springframework.org/schema/context/spring-context.xsd">
 <import
 resource="service.xml"/>
 <import
 resource="dao.xml"/>
 beans>

applicationContext.xml什么都不干，它只管涉及到整体需要的配置，并且集中管理。
这里引入了两个配置文件service.xml和dao.xml分别用于业务、数据处理。
service.xml

 xmlversion="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/beanshttp://www.springframework.org/schema/beans/spring-beans.xsd
 http://www.springframework.org/schema/contexthttp://www.springframework.org/schema/context/spring-context.xsd">
 <context:component-scan
 base-package="org.zlex.spring.service"/>
 beans>

注意，这里通过标签指定了业务层的基础包路径——“org.zlex.spring.service”。也就是说，业务层相关实现均在这一层。这是有必要的分层之一。
dao.xml

 xmlversion="1.0"encoding="UTF-8"?>
 <beans
 xmlns="http://www.springframework.org/schema/beans"
 xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
 xmlns:aop="http://www.springframework.org/schema/aop"
 xmlns:context="http://www.springframework.org/schema/context"
 xmlns:tx="http://www.springframework.org/schema/tx"
 xsi:schemaLocation="http://www.springframework.org/schema/beanshttp://www.springframework.org/schema/beans/spring-beans.xsd
 http://www.springframework.org/schema/aophttp://www.springframework.org/schema/aop/spring-aop.xsd
 http://www.springframework.org/schema/contexthttp://www.springframework.org/schema/context/spring-context.xsd
 http://www.springframework.org/schema/txhttp://www.springframework.org/schema/tx/spring-tx.xsd">
 <context:component-scan
 base-package="org.zlex.spring.dao"/>
 beans>

dao层如法炮制，包路径是"org.zlex.spring.dao"。从这个角度看，注解还是很方便的！
最后，我们看看servlet.xml

 xmlversion="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/beanshttp://www.springframework.org/schema/beans/spring-beans.xsd
 http://www.springframework.org/schema/contexthttp://www.springframework.org/schema/context/spring-context.xsd">
 <context:component-scan
 base-package="org.zlex.spring.controller"/>
 <bean
 id="urlMapping"
 class="org.springframework.web.servlet.mvc.annotation.DefaultAnnotationHandlerMapping"/>
 <bean
 class="org.springframework.web.servlet.mvc.annotation.AnnotationMethodHandlerAdapter"/>
 beans>

包路径配置就不细说了，都是一个概念。最重要的时候后面两个配置，这将使得注解生效！
“org.springframework.web.servlet.mvc.annotation.DefaultAnnotationHandlerMapping”是默认实现，可以不写，Spring容器默认会默认使用该类。
“org.springframework.web.servlet.mvc.annotation.AnnotationMethodHandlerAdapter”直接关系到多动作控制器配置是否可用！
简单看一下代码结构，如图：

Account类是来存储账户信息，属于域对象，极为简单，代码如下所示：
Account.java

 /**
 *2010-1-23
 */
 packageorg.zlex.spring.domain;

 importjava.io.Serializable;

 /**
 *
 *@author梁栋
 *@version1.0
 *@since1.0
 */
 publicclassAccountimplementsSerializable{

 /**
 *
 */
 privatestaticfinallongserialVersionUID=-533698031946372178L;

 privateStringusername;
 privateStringpassword;

 /**
 *@paramusername
 *@parampassword
 */
 publicAccount(Stringusername,Stringpassword){
 this.username=username;
 this.password=password;
 }

 /**
 *@returntheusername
 */
 publicStringgetUsername(){
 returnusername;
 }

 /**
 *@paramusernametheusernametoset
 */
 publicvoidsetUsername(Stringusername){
 this.username=username;
 }

 /**
 *@returnthepassword
 */
 publicStringgetPassword(){
 returnpassword;
 }

 /**
 *@parampasswordthepasswordtoset
 */
 publicvoidsetPassword(Stringpassword){
 this.password=password;
 }


 }

通常，在构建域对象时，需要考虑该对象可能需要进行网络传输，本地缓存，因此建议实现序列化接口Serializable
我们再来看看控制器，这就稍微复杂了一点代码如下所示：
AccountController .java

 /**
 *2010-1-23
 */
 packageorg.zlex.spring.controller;

 importjavax.servlet.http.HttpServletRequest;
 importjavax.servlet.http.HttpServletResponse;

 importorg.springframework.beans.factory.annotation.Autowired;
 importorg.springframework.stereotype.Controller;
 importorg.springframework.web.bind.ServletRequestUtils;
 importorg.springframework.web.bind.annotation.RequestMapping;
 importorg.springframework.web.bind.annotation.RequestMethod;
 importorg.zlex.spring.service.AccountService;

 /**
 *
 *@author梁栋
 *@version1.0
 *@since1.0
 */
 @Controller
 @RequestMapping("/account.do")
 publicclassAccountController{

 @Autowired
 privateAccountServiceaccountService;

 @RequestMapping(method=RequestMethod.GET)
 publicvoidhello(HttpServletRequestrequest,HttpServletResponseresponse)
 throwsException{

 Stringusername=ServletRequestUtils.getRequiredStringParameter(
 request,"username");
 Stringpassword=ServletRequestUtils.getRequiredStringParameter(
 request,"password");
 System.out.println(accountService.verify(username,password));
 }
 }

分段详述：

 @Controller
 @RequestMapping("/account.do")

这两行注解， @Controller 是告诉Spring容器，这是一个控制器类， @RequestMapping("/account.do") 是来定义该控制器对应的请求路径（/account.do）

 @Autowired
 privateAccountServiceaccountService;

这是用来自动织入业务层实现AccountService，有了这个注解，我们就可以不用写setAccountService()方法了！
同时，JSR-250标准注解，推荐使用 @Resource 来代替Spring专有的@Autowired注解。

引用

Spring 不但支持自己定义的@Autowired注解，还支持几个由JSR-250规范定义的注解，它们分别是@Resource、@PostConstruct以及@PreDestroy。

　　@Resource的作用相当于@Autowired，只不过@Autowired按byType自动注入，而@Resource默认按 byName自动注入罢了。@Resource有两个属性是比较重要的，分别是name和type，Spring将@Resource注解的name属性解析为bean的名字，而type属性则解析为bean的类型。所以如果使用name属性，则使用byName的自动注入策略，而使用type属性时则使用byType自动注入策略。如果既不指定name也不指定type属性，这时将通过反射机制使用byName自动注入策略。

　　@Resource装配顺序

　　1. 如果同时指定了name和type，则从Spring上下文中找到唯一匹配的bean进行装配，找不到则抛出异常

　　2. 如果指定了name，则从上下文中查找名称（id）匹配的bean进行装配，找不到则抛出异常

　　3. 如果指定了type，则从上下文中找到类型匹配的唯一bean进行装配，找不到或者找到多个，都会抛出异常

　　4. 如果既没有指定name，又没有指定type，则自动按照byName方式进行装配（见2）；如果没有匹配，则回退为一个原始类型（UserDao）进行匹配，如果匹配则自动装配；

　　1.6. @PostConstruct（JSR-250）

在方法上加上注解@PostConstruct，这个方法就会在Bean初始化之后被Spring容器执行（注：Bean初始化包括，实例化Bean，并装配Bean的属性（依赖注入））。

这有点像ORM最终被JPA一统天下的意思！ 大家知道就可以了，具体使用何种标准由项目说了算！
最后，来看看核心方法：

 @RequestMapping(method=RequestMethod.GET)
 publicvoidhello(HttpServletRequestrequest,HttpServletResponseresponse)
 throwsException{

 Stringusername=ServletRequestUtils.getRequiredStringParameter(
 request,"username");
 Stringpassword=ServletRequestUtils.getRequiredStringParameter(
 request,"password");
 System.out.println(accountService.verify(username,password));
 }

注解@RequestMapping(method = RequestMethod.GET)指定了访问方法类型。
注意，如果没有用这个注解标识方法，Spring容器将不知道那个方法可以用于处理get请求！
对于方法名，我们可以随意定！方法中的参数，类似于“HttpServletRequest request, HttpServletResponse response”，只要你需要方法可以是有参也可以是无参！
解析来看Service层，分为接口和实现：
AccountService.java

 /**
 *2010-1-23
 */
 packageorg.zlex.spring.service;

 /**
 *
 *@author梁栋
 *@version1.0
 *@since1.0
 */
 publicinterfaceAccountService{

 /**
 *验证用户身份
 *
 *@paramusername
 *@parampassword
 *@return
 */
 booleanverify(Stringusername,Stringpassword);

 }

接口不需要任何Spring注解相关的东西，它就是一个简单的接口！
重要的部分在于实现层，如下所示：
AccountServiceImpl.java

 /**
 *2010-1-23
 */
 packageorg.zlex.spring.service.impl;

 importorg.springframework.beans.factory.annotation.Autowired;
 importorg.springframework.stereotype.Service;
 importorg.springframework.transaction.annotation.Transactional;
 importorg.zlex.spring.dao.AccountDao;
 importorg.zlex.spring.domain.Account;
 importorg.zlex.spring.service.AccountService;

 /**
 *
 *@author梁栋
 *@version1.0
 *@since1.0
 */
 @Service
 @Transactional
 publicclassAccountServiceImplimplementsAccountService{

 @Autowired
 privateAccountDaoaccountDao;

 /*
 *(non-Javadoc)
 *
 *@seeorg.zlex.spring.service.AccountService#verify(java.lang.String,
 *java.lang.String)
 */
 @Override
 publicbooleanverify(Stringusername,Stringpassword){

 Accountaccount=accountDao.read(username);

 if(password.equals(account.getPassword())){
 returntrue;
 }else{
 returnfalse;
 }
 }

 }

注意以下内容：

 @Service
 @Transactional

注解@Service用于标识这是一个Service层实现，@Transactional用于控制事务，将事务定位在业务层，这是非常务实的做法！
接下来，我们来看持久层：AccountDao和AccountDaoImpl类
AccountDao.java

 /**
 *2010-1-23
 */
 packageorg.zlex.spring.dao;

 importorg.zlex.spring.domain.Account;

 /**
 *
 *@author梁栋
 *@version1.0
 *@since1.0
 */
 publicinterfaceAccountDao{

 /**
 *读取用户信息
 *
 *@paramusername
 *@return
 */
 Accountread(Stringusername);

 }

这个接口就是简单的数据提取，无需任何Spring注解有关的东西！
再看其实现类：
AccountDaoImpl.java

 /**
 *2010-1-23
 */
 packageorg.zlex.spring.dao.impl;

 importorg.springframework.stereotype.Repository;
 importorg.zlex.spring.dao.AccountDao;
 importorg.zlex.spring.domain.Account;

 /**
 *
 *@author梁栋
 *@version1.0
 *@since1.0
 */
 @Repository
 publicclassAccountDaoImplimplementsAccountDao{

 /*(non-Javadoc)
 *@seeorg.zlex.spring.dao.AccountDao#read(java.lang.String)
 */
 @Override
 publicAccountread(Stringusername){

 returnnewAccount(username,"wolf");
 }

 }

这里只需要注意注解：

 @Repository

意为持久层，Dao实现这层我没有过于细致的介绍通过注解调用ORM或是JDBC来完成实现，这些内容后续细述！
这里我们没有提到注解 @Component ，共有4种“组件”式注解：

引用

@Component:可装载组件
@Repository:持久层组件
@Service:服务层组件
@Controller:控制层组件

这样spring容器就完成了控制层、业务层和持久层的构建。
启动应用，访问 http://localhost:8080/spring/account.do?username=snow&password=wolf
观察控制台，如果得到包含“true”的输出，本次构建就成功了！

代码见附件！

顺便说一句：在Spring之前的XML配置中，如果你想在一个类中获得文件可以通过在xml配置这个类的某个属性。在注解的方式（Spring3.0）中，你可以使用 @Value 来指定这个文件。
例如，我们想要在一个类中获得一个文件，可以这样写：

 @Value("/WEB-INF/database.properties")
 privateFiledatabaseConfig;

如果这个properties文件已经正常在容器中加载，可以直接这样写：

 @Value("${jdbc.url}")
 privateStringurl;

获得这个url参数！

容器中加载这个Properties文件：

 <util:propertiesid="jdbc"location="/WEB-INF/database.properties"/>

这样，我们就能通过注解 @Value 获得 /WEB-INF/database.properties 这个文件！
如果我们想要获得注入在xml中的某个类，例如dataSource（）可以在注解的类中这么写：

 @Resource(name="dataSource")
 privateBasicDataSourcedataSource;

如果只有这么一个类使用该配置文件：

 @ImportResource("/WEB-INF/database.properties")
 publicclassAccountDaoImplextendsAccountDao{

就这么简单！