Spring 注解学习手札（一） 构建简单Web应用
程序员文章站
2022-07-08 14:45:19
...
近来工作发生了一些变化，有必要学习一下Spring注解了！ :D
网上找了一些个例子，总的说来比较土，大多数是转载摘抄，按照提示弄下来根本都运行不了，索性自己趟一遍这浑水，在这里留下些个印记。
这次，先来构建一个极为简单的web应用，从controller到dao。不考虑具体实现，只是先对整体架构有一个清晰的了解。日后在分层细述每一层的细节。 :D
[b]相关参考：
[url=/blog/577989]Spring 注解学习手札（一） 构建简单Web应用[/url]
[url=/blog/578452]Spring 注解学习手札（二） 控制层梳理[/url]
[url=/blog/580194]Spring 注解学习手札（三） 表单页面处理[/url]
[url=/blog/583161]Spring 注解学习手札（四） 持久层浅析[/url]
[url=/blog/587602]Spring 注解学习手札（五） 业务层事务处理[/url]
[url=/blog/588351]Spring 注解学习手札（六） 测试[/url]
[url=/blog/1628861]Spring 注解学习手札（七） 补遗——@ResponseBody，@RequestBody，@PathVariable[/url]
[url=/blog/1636050]Spring 注解学习手札（八） 补遗——@ExceptionHandler[/url]
[/b]
我们将用到如下jar包：
[quote]
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
[/quote]
先看web.xml
有不少人问我，这段代码是什么：
这是当前应用的路径变量，也就是说你可以在其他代码中使用${spring.webapp.root}指代当前应用路径。我经常用它来设置log的输出目录。
为什么要设置参数log4jConfigLocation？
这是一种基本配置，spring中很多代码使用了不同的日志接口，既有log4j也有commons-logging，这里只是强制转换为log4j！并且，log4j的配置文件只能放在classpath根路径。同时，需要通过commons-logging配置将日志控制权转交给log4j。同时commons-logging.properties必须放置在classpath根路径。
commons-logging内容：
最后，记得配置log4j的监听器：
接下来，我们需要配置两套配置文件，applicationContext.xml和servlet.xml。
applicationContext.xml用于对应用层面做整体控制。按照分层思想，统领service层和dao层。servlet.xml则单纯控制controller层。
applicationContext.xml什么都不干，它只管涉及到整体需要的配置，并且集中管理。
这里引入了两个配置文件service.xml和dao.xml分别用于业务、数据处理。
service.xml
注意，这里通过<context:component-scan />标签指定了业务层的基础包路径——“org.zlex.spring.service”。也就是说，业务层相关实现均在这一层。这是有必要的分层之一。
dao.xml
dao层如法炮制，包路径是"org.zlex.spring.dao"。从这个角度看，注解还是很方便的！ :D
最后，我们看看servlet.xml
包路径配置就不细说了，都是一个概念。最重要的时候后面两个配置，这将使得注解生效！ :D
[color=red]“org.springframework.web.servlet.mvc.annotation.DefaultAnnotationHandlerMapping”是默认实现，可以不写，Spring容器默认会默认使用该类。
“org.springframework.web.servlet.mvc.annotation.AnnotationMethodHandlerAdapter”直接关系到多动作控制器配置是否可用！[/color]
简单看一下代码结构，如图：
[img]http://dl.iteye.com/upload/attachment/197483/acfea974-d089-30fd-8820-0f502566e777.jpg[/img]
Account类是来存储账户信息，属于域对象，极为简单，代码如下所示：
Account.java
通常，在构建域对象时，需要考虑该对象可能需要进行网络传输，本地缓存，因此建议实现序列化接口Serializable :D
我们再来看看控制器，这就稍微复杂了一点代码如下所示：
AccountController .java
分段详述：
这两行注解，[b]@Controller[/b]是告诉Spring容器，这是一个控制器类，[b]@RequestMapping("/account.do")[/b]是来定义该控制器对应的请求路径（/account.do）
这是用来自动织入业务层实现AccountService，有了这个注解，我们就可以不用写setAccountService()方法了！ :D
同时，JSR-250标准注解，推荐使用[b]@Resource[/b]来代替Spring专有的@Autowired注解。
[quote]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的属性（依赖注入））。[/quote]
这有点像ORM最终被JPA一统天下的意思！ :D 大家知道就可以了，具体使用何种标准由项目说了算！ :)
最后，来看看核心方法：
注解@RequestMapping(method = RequestMethod.GET)指定了访问方法类型。
注意，如果没有用这个注解标识方法，Spring容器将不知道那个方法可以用于处理get请求！ :)
对于方法名，我们可以随意定！方法中的参数，类似于“HttpServletRequest request, HttpServletResponse response”，只要你需要方法可以是有参也可以是无参！
解析来看Service层，分为接口和实现：
AccountService.java
接口不需要任何Spring注解相关的东西，它就是一个简单的接口！
重要的部分在于实现层，如下所示：
AccountServiceImpl.java
注意以下内容：
注解@Service用于标识这是一个Service层实现，@Transactional用于控制事务，将事务定位在业务层，这是非常务实的做法！ :)
接下来，我们来看持久层：AccountDao和AccountDaoImpl类
AccountDao.java
这个接口就是简单的数据提取，无需任何Spring注解有关的东西！
再看其实现类：
AccountDaoImpl.java
这里只需要注意注解：
意为持久层，Dao实现这层我没有过于细致的介绍通过注解调用ORM或是JDBC来完成实现，这些内容后续细述！
这里我们没有提到注解[b]@Component[/b]，共有4种“组件”式注解：
[quote]
@Component:可装载组件
@Repository:持久层组件
@Service:服务层组件
@Controller:控制层组件
[/quote]
这样spring容器就完成了控制层、业务层和持久层的构建。
启动应用，访问[url]http://localhost:8080/spring/account.do?username=snow&password=wolf[/url]
观察控制台，如果得到包含“true”的输出，本次构建就成功了！ :D
[img]http://dl.iteye.com/upload/attachment/197488/9447d026-3250-30cd-962d-88da029687f8.jpg[/img]
代码见附件！ :D
顺便说一句：在Spring之前的XML配置中，如果你想在一个类中获得文件可以通过在xml配置这个类的某个属性。在注解的方式（Spring3.0）中，你可以使用[b]@Value[/b]来指定这个文件。
例如，我们想要在一个类中获得一个文件，可以这样写：
如果这个properties文件已经正常在容器中加载，可以直接这样写：
获得这个url参数！ :D
容器中加载这个Properties文件：
这样，我们就能通过注解[b]@Value[/b]获得[b]/WEB-INF/database.properties[/b]这个文件！ :D
如果我们想要获得注入在xml中的某个类，例如dataSource（<bean id ="dataSource">）可以在注解的类中这么写：
如果只有这么一个类使用该配置文件：
就这么简单！ :D
[b]相关参考：
[url=/blog/577989]Spring 注解学习手札（一） 构建简单Web应用[/url]
[url=/blog/578452]Spring 注解学习手札（二） 控制层梳理[/url]
[url=/blog/580194]Spring 注解学习手札（三） 表单页面处理[/url]
[url=/blog/583161]Spring 注解学习手札（四） 持久层浅析[/url]
[url=/blog/587602]Spring 注解学习手札（五） 业务层事务处理[/url]
[url=/blog/588351]Spring 注解学习手札（六） 测试[/url]
[url=/blog/1628861]Spring 注解学习手札（七） 补遗——@ResponseBody，@RequestBody，@PathVariable[/url]
[url=/blog/1636050]Spring 注解学习手札（八） 补遗——@ExceptionHandler[/url]
[/b]
网上找了一些个例子，总的说来比较土，大多数是转载摘抄，按照提示弄下来根本都运行不了，索性自己趟一遍这浑水，在这里留下些个印记。
这次，先来构建一个极为简单的web应用，从controller到dao。不考虑具体实现，只是先对整体架构有一个清晰的了解。日后在分层细述每一层的细节。 :D
[b]相关参考：
[url=/blog/577989]Spring 注解学习手札（一） 构建简单Web应用[/url]
[url=/blog/578452]Spring 注解学习手札（二） 控制层梳理[/url]
[url=/blog/580194]Spring 注解学习手札（三） 表单页面处理[/url]
[url=/blog/583161]Spring 注解学习手札（四） 持久层浅析[/url]
[url=/blog/587602]Spring 注解学习手札（五） 业务层事务处理[/url]
[url=/blog/588351]Spring 注解学习手札（六） 测试[/url]
[url=/blog/1628861]Spring 注解学习手札（七） 补遗——@ResponseBody，@RequestBody，@PathVariable[/url]
[url=/blog/1636050]Spring 注解学习手札（八） 补遗——@ExceptionHandler[/url]
[/b]
我们将用到如下jar包：
[quote]
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
[/quote]
先看web.xml
<?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"
xmlns:web="http://java.sun.com/xml/ns/javaee/web-app_2_5.xsd"
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>spring</display-name>
<!-- 应用路径 -->
<context-param>
<param-name>webAppRootKey</param-name>
<param-value>spring.webapp.root</param-value>
</context-param>
<!-- Log4J 配置 -->
<context-param>
<param-name>log4jConfigLocation</param-name>
<param-value>classpath:log4j.xml</param-value>
</context-param>
<context-param>
<param-name>log4jRefreshInterval</param-name>
<param-value>60000</param-value>
</context-param>
<!--Spring上下文 配置 -->
<context-param>
<param-name>contextConfigLocation</param-name>
<param-value>/WEB-INF/applicationContext.xml</param-value>
</context-param>
<!-- 字符集 过滤器 -->
<filter>
<filter-name>CharacterEncodingFilter</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>
<init-param>
<param-name>forceEncoding</param-name>
<param-value>true</param-value>
</init-param>
</filter>
<filter-mapping>
<filter-name>CharacterEncodingFilter</filter-name>
<url-pattern>/*</url-pattern>
</filter-mapping>
<!-- Spring 监听器 -->
<listener>
<listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
</listener>
<listener>
<listener-class>org.springframework.web.util.Log4jConfigListener</listener-class>
</listener>
<!-- Spring 分发器 -->
<servlet>
<servlet-name>spring</servlet-name>
<servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
<init-param>
<param-name>contextConfigLocation</param-name>
<param-value>/WEB-INF/servlet.xml</param-value>
</init-param>
</servlet>
<servlet-mapping>
<servlet-name>spring</servlet-name>
<url-pattern>*.do</url-pattern>
</servlet-mapping>
<welcome-file-list>
<welcome-file>index.html</welcome-file>
<welcome-file>index.htm</welcome-file>
<welcome-file>index.jsp</welcome-file>
<welcome-file>default.html</welcome-file>
<welcome-file>default.htm</welcome-file>
<welcome-file>default.jsp</welcome-file>
</welcome-file-list>
</web-app>
有不少人问我，这段代码是什么：
<!-- 应用路径 -->
<context-param>
<param-name>webAppRootKey</param-name>
<param-value>spring.webapp.root</param-value>
</context-param>
这是当前应用的路径变量，也就是说你可以在其他代码中使用${spring.webapp.root}指代当前应用路径。我经常用它来设置log的输出目录。
为什么要设置参数log4jConfigLocation？
<!-- Log4J 配置 -->
<context-param>
<param-name>log4jConfigLocation</param-name>
<param-value>classpath:log4j.xml</param-value>
</context-param>
<context-param>
<param-name>log4jRefreshInterval</param-name>
<param-value>60000</param-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.Log4jConfigListener</listener-class>
</listener>
接下来，我们需要配置两套配置文件，applicationContext.xml和servlet.xml。
applicationContext.xml用于对应用层面做整体控制。按照分层思想，统领service层和dao层。servlet.xml则单纯控制controller层。
<?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.xsd
http://www.springframework.org/schema/context http://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
<?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.xsd
http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd">
<context:component-scan
base-package="org.zlex.spring.service" />
</beans>
注意，这里通过<context:component-scan />标签指定了业务层的基础包路径——“org.zlex.spring.service”。也就是说，业务层相关实现均在这一层。这是有必要的分层之一。
dao.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: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/beans http://www.springframework.org/schema/beans/spring-beans.xsd
http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop.xsd
http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd
http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx.xsd">
<context:component-scan
base-package="org.zlex.spring.dao" />
</beans>
dao层如法炮制，包路径是"org.zlex.spring.dao"。从这个角度看，注解还是很方便的！ :D
最后，我们看看servlet.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.xsd
http://www.springframework.org/schema/context http://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>
包路径配置就不细说了，都是一个概念。最重要的时候后面两个配置，这将使得注解生效！ :D
[color=red]“org.springframework.web.servlet.mvc.annotation.DefaultAnnotationHandlerMapping”是默认实现，可以不写，Spring容器默认会默认使用该类。
“org.springframework.web.servlet.mvc.annotation.AnnotationMethodHandlerAdapter”直接关系到多动作控制器配置是否可用！[/color]
简单看一下代码结构，如图：
[img]http://dl.iteye.com/upload/attachment/197483/acfea974-d089-30fd-8820-0f502566e777.jpg[/img]
Account类是来存储账户信息，属于域对象，极为简单，代码如下所示：
Account.java
/**
* 2010-1-23
*/
package org.zlex.spring.domain;
import java.io.Serializable;
/**
*
* @author <a href="mailto:[email protected]">梁栋</a>
* @version 1.0
* @since 1.0
*/
public class Account implements Serializable {
/**
*
*/
private static final long serialVersionUID = -533698031946372178L;
private String username;
private String password;
/**
* @param username
* @param password
*/
public Account(String username, String password) {
this.username = username;
this.password = password;
}
/**
* @return the username
*/
public String getUsername() {
return username;
}
/**
* @param username the username to set
*/
public void setUsername(String username) {
this.username = username;
}
/**
* @return the password
*/
public String getPassword() {
return password;
}
/**
* @param password the password to set
*/
public void setPassword(String password) {
this.password = password;
}
}
通常，在构建域对象时，需要考虑该对象可能需要进行网络传输，本地缓存，因此建议实现序列化接口Serializable :D
我们再来看看控制器，这就稍微复杂了一点代码如下所示：
AccountController .java
/**
* 2010-1-23
*/
package org.zlex.spring.controller;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.ServletRequestUtils;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;
import org.zlex.spring.service.AccountService;
/**
*
* @author <a href="mailto:[email protected]">梁栋</a>
* @version 1.0
* @since 1.0
*/
@Controller
@RequestMapping("/account.do")
public class AccountController {
@Autowired
private AccountService accountService;
@RequestMapping(method = RequestMethod.GET)
public void hello(HttpServletRequest request, HttpServletResponse response)
throws Exception {
String username = ServletRequestUtils.getRequiredStringParameter(
request, "username");
String password = ServletRequestUtils.getRequiredStringParameter(
request, "password");
System.out.println(accountService.verify(username, password));
}
}
分段详述：
@Controller
@RequestMapping("/account.do")
这两行注解，[b]@Controller[/b]是告诉Spring容器，这是一个控制器类，[b]@RequestMapping("/account.do")[/b]是来定义该控制器对应的请求路径（/account.do）
@Autowired
private AccountService accountService;
这是用来自动织入业务层实现AccountService，有了这个注解，我们就可以不用写setAccountService()方法了！ :D
同时，JSR-250标准注解，推荐使用[b]@Resource[/b]来代替Spring专有的@Autowired注解。
[quote]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的属性（依赖注入））。[/quote]
这有点像ORM最终被JPA一统天下的意思！ :D 大家知道就可以了，具体使用何种标准由项目说了算！ :)
最后，来看看核心方法：
@RequestMapping(method = RequestMethod.GET)
public void hello(HttpServletRequest request, HttpServletResponse response)
throws Exception {
String username = ServletRequestUtils.getRequiredStringParameter(
request, "username");
String password = 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
*/
package org.zlex.spring.service;
/**
*
* @author <a href="mailto:[email protected]">梁栋</a>
* @version 1.0
* @since 1.0
*/
public interface AccountService {
/**
* 验证用户身份
*
* @param username
* @param password
* @return
*/
boolean verify(String username, String password);
}
接口不需要任何Spring注解相关的东西，它就是一个简单的接口！
重要的部分在于实现层，如下所示：
AccountServiceImpl.java
/**
* 2010-1-23
*/
package org.zlex.spring.service.impl;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import org.zlex.spring.dao.AccountDao;
import org.zlex.spring.domain.Account;
import org.zlex.spring.service.AccountService;
/**
*
* @author <a href="mailto:[email protected]">梁栋</a>
* @version 1.0
* @since 1.0
*/
@Service
@Transactional
public class AccountServiceImpl implements AccountService {
@Autowired
private AccountDao accountDao;
/*
* (non-Javadoc)
*
* @see org.zlex.spring.service.AccountService#verify(java.lang.String,
* java.lang.String)
*/
@Override
public boolean verify(String username, String password) {
Account account = accountDao.read(username);
if (password.equals(account.getPassword())) {
return true;
} else {
return false;
}
}
}
注意以下内容：
@Service
@Transactional
注解@Service用于标识这是一个Service层实现，@Transactional用于控制事务，将事务定位在业务层，这是非常务实的做法！ :)
接下来，我们来看持久层：AccountDao和AccountDaoImpl类
AccountDao.java
/**
* 2010-1-23
*/
package org.zlex.spring.dao;
import org.zlex.spring.domain.Account;
/**
*
* @author <a href="mailto:[email protected]">梁栋</a>
* @version 1.0
* @since 1.0
*/
public interface AccountDao {
/**
* 读取用户信息
*
* @param username
* @return
*/
Account read(String username);
}
这个接口就是简单的数据提取，无需任何Spring注解有关的东西！
再看其实现类：
AccountDaoImpl.java
/**
* 2010-1-23
*/
package org.zlex.spring.dao.impl;
import org.springframework.stereotype.Repository;
import org.zlex.spring.dao.AccountDao;
import org.zlex.spring.domain.Account;
/**
*
* @author <a href="mailto:[email protected]">梁栋</a>
* @version 1.0
* @since 1.0
*/
@Repository
public class AccountDaoImpl implements AccountDao {
/* (non-Javadoc)
* @see org.zlex.spring.dao.AccountDao#read(java.lang.String)
*/
@Override
public Account read(String username) {
return new Account(username,"wolf");
}
}
这里只需要注意注解：
@Repository
意为持久层，Dao实现这层我没有过于细致的介绍通过注解调用ORM或是JDBC来完成实现，这些内容后续细述！
这里我们没有提到注解[b]@Component[/b]，共有4种“组件”式注解：
[quote]
@Component:可装载组件
@Repository:持久层组件
@Service:服务层组件
@Controller:控制层组件
[/quote]
这样spring容器就完成了控制层、业务层和持久层的构建。
启动应用，访问[url]http://localhost:8080/spring/account.do?username=snow&password=wolf[/url]
观察控制台，如果得到包含“true”的输出，本次构建就成功了！ :D
[img]http://dl.iteye.com/upload/attachment/197488/9447d026-3250-30cd-962d-88da029687f8.jpg[/img]
代码见附件！ :D
顺便说一句：在Spring之前的XML配置中，如果你想在一个类中获得文件可以通过在xml配置这个类的某个属性。在注解的方式（Spring3.0）中，你可以使用[b]@Value[/b]来指定这个文件。
例如，我们想要在一个类中获得一个文件，可以这样写：
@Value("/WEB-INF/database.properties")
private File databaseConfig;
如果这个properties文件已经正常在容器中加载，可以直接这样写：
@Value("${jdbc.url}")
private String url;获得这个url参数！ :D
容器中加载这个Properties文件：
<util:properties id="jdbc" location="/WEB-INF/database.properties"/>这样，我们就能通过注解[b]@Value[/b]获得[b]/WEB-INF/database.properties[/b]这个文件！ :D
如果我们想要获得注入在xml中的某个类，例如dataSource（<bean id ="dataSource">）可以在注解的类中这么写：
@Resource(name = "dataSource")
private BasicDataSource dataSource;
如果只有这么一个类使用该配置文件：
@ImportResource("/WEB-INF/database.properties")
public class AccountDaoImpl extends AccountDao {就这么简单！ :D
[b]相关参考：
[url=/blog/577989]Spring 注解学习手札（一） 构建简单Web应用[/url]
[url=/blog/578452]Spring 注解学习手札（二） 控制层梳理[/url]
[url=/blog/580194]Spring 注解学习手札（三） 表单页面处理[/url]
[url=/blog/583161]Spring 注解学习手札（四） 持久层浅析[/url]
[url=/blog/587602]Spring 注解学习手札（五） 业务层事务处理[/url]
[url=/blog/588351]Spring 注解学习手札（六） 测试[/url]
[url=/blog/1628861]Spring 注解学习手札（七） 补遗——@ResponseBody，@RequestBody，@PathVariable[/url]
[url=/blog/1636050]Spring 注解学习手札（八） 补遗——@ExceptionHandler[/url]
[/b]
上一篇： 楚国那么强大，为什么最后会被秦国灭了呢?