在Spring MVC中的配置中一般會遇到這兩個標簽，作為<context:component-scan>的子標簽出現(xiàn)。

但在使用時要注意一下幾點：

1.在很多配置中一般都會吧Spring-common.xml和Spring-MVC.xml進行分開配置，這種配置就行各施其職一樣，顯得特別清晰。

在Spring-MVC.xml中只對@Controller進行掃描就可，作為一個控制器，其他的事情不做。

在Spring-common.xml中只對一些事務邏輯的注解掃描。

2.現(xiàn)在給定一個項目包的機構(gòu):

com.fq.controlller

com.fq.service

就先給定這兩個包機構(gòu)

（1）在Spring-MVC.xml中有以下配置：

<!-- 掃描@Controller注解 -->
<context:component-scan base-package="com.fq.controller">
    <context:include-filter type="annotation"
        expression="org.springframework.stereotype.Controller" />
</context:component-scan>

可以看出要把最終的包寫上，而不能這樣寫base-package=”com.fq”。這種寫法對于include-filter來講它都會掃描，而不是僅僅掃描@Controller。哈哈哈，這點需要注意。他一般會導致一個常見的錯誤，那就是事務不起作用，補救的方法是添加use-default-filters=”false”。

（2）在Spring-common.xml中有如下配置：

<!-- 配置掃描注解,不掃描@Controller注解 -->
<context:component-scan base-package="com.fq">
    <context:exclude-filter type="annotation"
        expression="org.springframework.stereotype.Controller" />
</context:component-scan>

可以看到，他是要掃描com.fq包下的所有子類，不包含@Controller。對于exculude-filter不存在包不精確后都進行掃描的問題。

myeclipse自定義java注釋：

Window->Preference->Java->Code Style->Code Template

然后展開Comments節(jié)點就是所有需設置注釋的元素

-----------------

文件 (Files) 注釋標簽：

/** 

* @Project : ${project_name}

* @Title : ${file_name}

* @Package ${package_name}

* @Description : ${todo}

* @author shenyanghong ahong2011@gmail.com

* @date ${date} ${time}

* @Copyright : ${year} www.1000chi.com Inc. All rights reserved.

* @version V1.0 

*/

類 (Types) 注釋標簽（類的注釋）：

/**

  * @ClassName ${type_name}

  * @Description ${todo}

  * @author shenyanghong ahong2011@gmail.com

  * @date ${date}

  * ${tags}

*/

字段 (Fields) 注釋標簽：

/** 
* @Fields ${field} : ${todo}
*/ 

構(gòu)造函數(shù)標簽：

/** 
* <p>Title: </p> 
* <p>Description: </p> 
* ${tags} 
*/

方法 (Constructor & Methods) 標簽：

/** 
* @Title: ${enclosing_method} 
* @Description: ${todo}
* @param ${tags}    設定文件 
* @return ${return_type}    返回類型 
* @throws 
*/

覆蓋方法 (Overriding Methods) 標簽：

/* ( 非 Javadoc) 
* <p>Title: ${enclosing_method}</p> 
* <p>Description: </p> 
* ${tags} 
* ${see_to_overridden} 
*/

代表方法 (Delegate Methods) 標簽：

/** 
* ${tags} 
* ${see_to_target} 
*/ 

getter 方法標簽：

/** 
* @return ${bare_field_name} 
*/

setter 方法標簽：

/** 
* @param ${param} 要設置的 ${bare_field_name} 
*/

今天將寫好的附件服務器的API發(fā)給同事

她引入我的jar后, 編譯就會報錯: 類文件具有錯誤的版本 50.0,應為 49.0

50.0 對應的是JDK的1.6版本, 而49.0 對應的是JDK的1.5版本

也就是說我的jar的版本高于她所用的版本

由于我們實際部署在1.5之上, 所以我就來修改我的編譯環(huán)境

首先我先修改了Eclipse的編譯環(huán)境到1.5, 但是沒有效果

轉(zhuǎn)眼一想, 我都是使用Ant來打包發(fā)布, 看來Ant是自己編譯的

于是我就在網(wǎng)上找到了修改Ant編譯版本的方法

最后完成了修改

寫個文字記錄下, 免得以后忘了= =

PS: 我發(fā)現(xiàn)很多人問如何查看class文件是什么版本JDK編譯的, 現(xiàn)在我將方法寫在下面:

使用UtralEdit打開一個class文件.

根據(jù)java虛擬機的規(guī)范, java的class文件的前4個字節(jié)為magic number(魔數(shù)), 0xCAFEBABE(下圖的第一行0 - 3列), 標識這個文件是java的class文件

而緊隨其后的4個字節(jié), 存儲的就是該class文件的主次版本號(下圖的第一行的 4 - 7 列), 下圖中的31 換算成十進制就是49, 這標識此class文件為JDK1.5編譯所得, 若32 就是JDK1.6編譯

@responsebody表示該方法的返回結(jié)果直接寫入HTTP response body中
一般在異步獲取數(shù)據(jù)時使用，在使用@RequestMapping后，返回值通常解析為跳轉(zhuǎn)路徑，加上@responsebody后返回結(jié)果不會被解析為跳轉(zhuǎn)路徑，而是直接寫入HTTP response body中。比如異步獲取json數(shù)據(jù)，加上@responsebody后，會直接返回json數(shù)據(jù)。
4、在以上配置都正確的情況下，我的項目還是不能返回json串。報錯：The resource identified by this request is only capable of generating responses with characteristics not acceptable according to the request "accept" headers ()。
今天終于在一個外文網(wǎng)站找到答案，是由于spring版本的問題引起的。我之前一直用的是3.0.0的版本。就是因為這個版本的問題。于是果斷去官網(wǎng)下載3.2版本的，一切正常運行，成功返回json數(shù)據(jù)。

struts和spring整合首先要在Web容器啟動的時候自動裝配ApplicationContext的配置信息，可想而知應該在web.xml做相應的配置：
[html]
<context-param> 
    <param-name>contextConfigLocation</param-name> 
    <param-value> 
        classpath:applicationContext.xml 
    </param-value> 
</context-param> 
<listener> 
       <listener-class>org.springframework.web.context.ContextLoaderListener</listener-class> 
   </listener> 
配置了org.springframework.web.context.ContextLoaderListener后我們就不惜要編寫代碼顯示地實例化ApplicationContext對象了。至于為什么要使用監(jiān)聽是因為web.xml 的加載順序是：context-param -> listener -> filter -> servlet 。如果你是在不想使用監(jiān)聽，或許你可以嘗試下繼承struts2的org.apache.struts2.dispatcher.ng.filter.StrutsPrepareAndExecuteFilter重寫這個它的init方法在StrutsPrepareAndExecuteFilter過濾器init中實例化ApplicationContext對象加載配置信息，雖然這種方法也可行，但是當攔截每個action都會加載一次配置信息，重新實例化了一個新的web容器，不僅浪費了資源也讓spring更加依賴了struts。

1、使用xml方式：
struts2配置
<package name="user" extends="struts-default">
<action name="login" class="userAction">
<result name="success">/success.jsp</result>
<result name="input" type="redirect">/index.jsp</result>
</action>
</package>
spring配置
<bean id="userDao" class="org.han.dao.impl.UserDaoImpl" />
<bean id="biz" class="org.han.service.impl.LoginBizImpl">
<property name="userdao" ref="userDao"/>
</bean>

<bean id="userAction" class="org.han.action.LoginAction" scope="prototype" >
<property name="biz" ref="biz" />
</bean>
注意紅色部分，struts2的action class與對應的action bean必須相同,這樣才能由spring管理action;

2、struts2使用零配置方式：
當你導入了零配置插件包的時候千萬要注意約定大于配置，還是上面的spring配置，只是不需要struts2配置了。
第一種方式：只需要將Action的className對應到spring配置中的bean id就行了
@Action(value = "/login", results = { @Result(name = "success", location = "/success.jsp"),@Result(name="input",location="/index.jsp")},className="userAction")
public String login() throws Exception {
// TODO Auto-generated method stub
User u=biz.login(this.getUser());
if(u!=null){
return SUCCESS;
}
return INPUT;
}
第二種方式：
Action注解不需要className了，將spring配置稍作修改
<bean id="org.han.action.LoginAction" class="org.han.action.LoginAction" scope="prototype" >
<property name="biz" ref="biz" />
</bean>
這樣可以是因為當你使用零配置的時候，action的class默認是當前類的全類名，所以和spring整合的時候剛好使用全類名在spring配置中查找以全類名為id的bean。

3、struts2、spring都使用注解方式：
www.2cto.com
<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"> 
   <context:component-scan base-package="org.han.dao.impl,org.han.service.impl,org.han.action"/> 
</beans> 

<context:component-scan base-package=""/>用此種方式，不需要在配置文件中再配置bean，也不需要再導入上面對應的處理bean。也就是說可以不需要在配置文件中使用<context:annotation-config/>了，因為此種方式會自動導入

[java]
@Namespace("/") 
@Component(value="userLogin") 
@Scope(value="prototype") 
public class LoginAction extends ActionSupport { 
 
    public LoginAction() { 
        super(); 
        // TODO Auto-generated constructor stub 
        System.out.println("action:"+this.hashCode()); 
    } 
     
    @Autowired 
    private ILoginBiz biz; 
    private User user; 
 
    public User getUser() { 
        return user; 
    } 
 
    public void setUser(User user) { 
        this.user = user; 
    } 
    @Autowired 
    public void setBiz(ILoginBiz biz) { 
        this.biz = biz; 
    } 
 
    @Override 
    @Action(value = "hello", results = { @Result(name = "success", location = "/success.jsp"),@Result(name="input",location="/index.jsp")}) 
    public String execute() throws Exception { 
        // TODO Auto-generated method stub 
        System.out.println("biz:"+this.biz.hashCode()); 
        User u=biz.login(this.getUser()); 
        if(u!=null){ 
            return SUCCESS; 
        } 
        return INPUT; 
    } 
} 
@Component 有一個可選的入?yún)ⅲ糜谥付?Bean 的名稱。一般情況下，Bean 都是 singleton 的，需要注入 Bean 的地方僅需要通過 byType 策略就可以自動注入了，所以大可不必指定 Bean 的名稱。除了提供 @Component 注釋外，還定義了幾個擁有特殊語義的注釋，它們分別是：@Repository、@Service 和 @Controller。在目前的 Spring 版本中，這 3 個注釋和 @Component 是等效的，但是從注釋類的命名上，很容易看出這 3 個注釋分別和持久層、業(yè)務層和控制層（Web 層）相對應。雖然目前這 3 個注釋和 @Component 相比沒有什么新意，但 Spring 將在以后的版本中為它們添加特殊的功能。所以，如果 Web 應用程序采用了經(jīng)典的三層分層結(jié)構(gòu)的話，最好在持久層、業(yè)務層和控制層分別采用 @Repository、@Service 和 @Controller 對分層中的類進行注釋，而用 @Component 對那些比較中立的類進行注釋。

@Scope用于定義Bean的作用范圍。

@Autowired 注釋，它可以對類成員變量、方法及構(gòu)造函數(shù)進行標注，完成自動裝配的工作。當 Spring 容器啟動時，AutowiredAnnotationBeanPostProcessor 將掃描 Spring 容器中所有 Bean，當發(fā)現(xiàn) Bean 中擁有 @Autowired 注釋時就找到和其匹配（默認按類型匹配）的 Bean，并注入到對應的地方中去。所以對成員變量使用 @Autowired 后，您大可將它們的 setter 方法刪除。

@Qualifier(“name”) 中的 name是 Bean 的名稱，所以 @Autowired 和 @Qualifier 結(jié)合使用時，自動注入的策略就從 byType 轉(zhuǎn)變成 byName 了。@Autowired 可以對成員變量、方法以及構(gòu)造函數(shù)進行注釋，而 @Qualifier 的標注對象是成員變量、方法入?yún)ⅰ?gòu)造函數(shù)入?yún)ⅰ?/p>

@PostConstruct 和 @PreDestroy:JSR-250 為初始化之后/銷毀之前方法的指定定義了兩個注釋類，這兩個注釋只能應用于方法上。標注了 @PostConstruct 注釋的方法將在類實例化后調(diào)用，而標注了 @PreDestroy 的方法將在類銷毀之前調(diào)用。
通過 <bean> 元素的 init-method/destroy-method 屬性進行配置，都只能為 Bean 指定一個初始化 / 銷毀的方法。但是使用 @PostConstruct 和 @PreDestroy 注釋卻可以指定多個初始化 / 銷毀方法，那些被標注 @PostConstruct 或@PreDestroy 注釋的方法都會在初始化 / 銷毀時被執(zhí)行。
更多的關(guān)于注解使用：請看官方文檔

4、總結(jié)：
1、注釋配置不一定在先天上優(yōu)于 XML 配置。如果 Bean 的依賴關(guān)系是固定的，（如 Service 使用了哪幾個 DAO 類），這種配置信息不會在部署時發(fā)生調(diào)整，那么注釋配置優(yōu)于 XML 配置；反之如果這種依賴關(guān)系會在部署時發(fā)生調(diào)整，XML 配置顯然又優(yōu)于注釋配置，因為注釋是對 Java 源代碼的調(diào)整，您需要重新改寫源代碼并重新編譯才可以實施調(diào)整。
2、如果 Bean 不是自己編寫的類（如 JdbcTemplate、SessionFactoryBean 等），注釋配置將無法實施，此時 XML 配置是唯一可用的方式。
3、注釋配置往往是類級別的，而 XML 配置則可以表現(xiàn)得更加靈活。比如相比于 @Transaction 事務注釋，使用 aop/tx 命名空間的事務配置更加靈活和簡單。
所以在實現(xiàn)應用中，我們往往需要同時使用注釋配置和 XML 配置，對于類級別且不會發(fā)生變動的配置可以優(yōu)先考慮注釋配置；而對于那些第三方類以及容易發(fā)生調(diào)整的配置則應優(yōu)先考慮使用 XML 配置。Spring 會在具體實施 Bean 創(chuàng)建和 Bean 注入之前將這兩種配置方式的元信息融合在一起。

來自：http://hanyexiaoxiao.iteye.com/blog/410123
1. 使用Spring注解來注入屬性 
1.1. 使用注解以前我們是怎樣注入屬性的 
類的實現(xiàn)：

public class UserManagerImpl implements UserManager {
	private UserDao userDao;
	public void setUserDao(UserDao userDao) {
		this.userDao = userDao;
	}
	...
}

配置文件：

<bean id="userManagerImpl" class="com.kedacom.spring.annotation.service.UserManagerImpl">
	<property name="userDao" ref="userDao" />
</bean>
<bean id="userDao" class="com.kedacom.spring.annotation.persistence.UserDaoImpl">
	<property name="sessionFactory" ref="mySessionFactory" />
</bean>

1.2. 引入@Autowired注解（不推薦使用，建議使用@Resource） 
類的實現(xiàn)（對成員變量進行標注）

public class UserManagerImpl implements UserManager {
	@Autowired
	private UserDao userDao;
	...
}

或者（對方法進行標注）

public class UserManagerImpl implements UserManager {
	private UserDao userDao;
	@Autowired
	public void setUserDao(UserDao userDao) {
		this.userDao = userDao;
	}
	...
}

配置文件

<bean id="userManagerImpl" class="com.kedacom.spring.annotation.service.UserManagerImpl" />
<bean id="userDao" class="com.kedacom.spring.annotation.persistence.UserDaoImpl">
	<property name="sessionFactory" ref="mySessionFactory" />
</bean>

@Autowired可以對成員變量、方法和構(gòu)造函數(shù)進行標注，來完成自動裝配的工作。以上兩種不同實現(xiàn)方式中，@Autowired的標注位置不同，它們都會在Spring在初始化userManagerImpl這個bean時，自動裝配userDao這個屬性，區(qū)別是：第一種實現(xiàn)中，Spring會直接將UserDao類型的唯一一個bean賦值給userDao這個成員變量；第二種實現(xiàn)中，Spring會調(diào)用setUserDao方法來將UserDao類型的唯一一個bean裝配到userDao這個屬性。 

1.3. 讓@Autowired工作起來 
要使@Autowired能夠工作，還需要在配置文件中加入以下代碼

<bean class="org.springframework.beans.factory.annotation.AutowiredAnnotationBeanPostProcessor" />

1.4. @Qualifier 
@Autowired是根據(jù)類型進行自動裝配的。在上面的例子中，如果當Spring上下文中存在不止一個UserDao類型的bean時，就會拋出BeanCreationException異常；如果Spring上下文中不存在UserDao類型的bean，也會拋出BeanCreationException異常。我們可以使用@Qualifier配合@Autowired來解決這些問題。 
1. 可能存在多個UserDao實例

	@Autowired
	public void setUserDao(@Qualifier("userDao") UserDao userDao) {
		this.userDao = userDao;
	}

這樣，Spring會找到id為userDao的bean進行裝配。 
2. 可能不存在UserDao實例

	@Autowired(required = false)
	public void setUserDao(UserDao userDao) {
		this.userDao = userDao;
	}

1.5. @Resource（JSR-250標準注解，推薦使用它來代替Spring專有的@Autowired注解） 
Spring 不但支持自己定義的@Autowired注解，還支持幾個由JSR-250規(guī)范定義的注解，它們分別是@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容器執(zhí)行（注：Bean初始化包括，實例化Bean，并裝配Bean的屬性（依賴注入））。 
它的一個典型的應用場景是，當你需要往Bean里注入一個其父類中定義的屬性，而你又無法復寫父類的屬性或?qū)傩缘膕etter方法時，如：

public class UserDaoImpl extends HibernateDaoSupport implements UserDao {
	private SessionFactory mySessionFacotry;
	@Resource
	public void setMySessionFacotry(SessionFactory sessionFacotry) {
		this.mySessionFacotry = sessionFacotry;
	}
	@PostConstruct
	public void injectSessionFactory() {
		super.setSessionFactory(mySessionFacotry);
	}
	...
}

這里通過@PostConstruct，為UserDaoImpl的父類里定義的一個sessionFactory私有屬性，注入了我們自己定義的sessionFactory（父類的setSessionFactory方法為final，不可復寫），之后我們就可以通過調(diào)用super.getSessionFactory()來訪問該屬性了。 

1.7. @PreDestroy（JSR-250） 
在方法上加上注解@PreDestroy，這個方法就會在Bean初始化之后被Spring容器執(zhí)行。由于我們當前還沒有需要用到它的場景，這里不不去演示。其用法同@PostConstruct。 

1.8. 使用<context:annotation-config />簡化配置 
Spring2.1添加了一個新的context的Schema命名空間，該命名空間對注釋驅(qū)動、屬性文件引入、加載期織入等功能提供了便捷的配置。我們知道注釋本身是不會做任何事情的，它僅提供元數(shù)據(jù)信息。要使元數(shù)據(jù)信息真正起作用，必須讓負責處理這些元數(shù)據(jù)的處理器工作起來。 
AutowiredAnnotationBeanPostProcessor和CommonAnnotationBeanPostProcessor就是處理這些注釋元數(shù)據(jù)的處理器。但是直接在Spring配置文件中定義這些Bean顯得比較笨拙。Spring為我們提供了一種方便的注冊這些BeanPostProcessor的方式，這就是<context:annotation-config />：

<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-2.5.xsd
	http://www.springframework.org/schema/context
	http://www.springframework.org/schema/context/spring-context-2.5.xsd">
	<context:annotation-config />
</beans>

<context:annotationconfig />將隱式地向Spring容器注冊AutowiredAnnotationBeanPostProcessor、CommonAnnotationBeanPostProcessor、 PersistenceAnnotationBeanPostProcessor以及RequiredAnnotationBeanPostProcessor這4個BeanPostProcessor。 

2. 使用Spring注解完成Bean的定義 
以上我們介紹了通過@Autowired或@Resource來實現(xiàn)在Bean中自動注入的功能，下面我們將介紹如何注解Bean，從而從XML配置文件中完全移除Bean定義的配置。 

2.1. @Component（不推薦使用）、@Repository、@Service、@Controller 
只需要在對應的類上加上一個@Component注解，就將該類定義為一個Bean了：

@Component
public class UserDaoImpl extends HibernateDaoSupport implements UserDao {
	...
}

使用@Component注解定義的Bean，默認的名稱（id）是小寫開頭的非限定類名。如這里定義的Bean名稱就是userDaoImpl。你也可以指定Bean的名稱： 
@Component("userDao") 
@Component是所有受Spring管理組件的通用形式，Spring還提供了更加細化的注解形式：@Repository、@Service、@Controller，它們分別對應存儲層Bean，業(yè)務層Bean，和展示層Bean。目前版本（2.5）中，這些注解與@Component的語義是一樣的，完全通用，在Spring以后的版本中可能會給它們追加更多的語義。所以，我們推薦使用@Repository、@Service、@Controller來替代@Component。 

2.2. 使用<context:component-scan />讓Bean定義注解工作起來

<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-2.5.xsd
	http://www.springframework.org/schema/context
	http://www.springframework.org/schema/context/spring-context-2.5.xsd">
	<context:component-scan base-package="com.kedacom.ksoa" />
</beans>

這里，所有通過<bean>元素定義Bean的配置內(nèi)容已經(jīng)被移除，僅需要添加一行<context:component-scan />配置就解決所有問題了——Spring XML配置文件得到了極致的簡化（當然配置元數(shù)據(jù)還是需要的，只不過以注釋形式存在罷了）。<context:component-scan />的base-package屬性指定了需要掃描的類包，類包及其遞歸子包中所有的類都會被處理。 
<context:component-scan />還允許定義過濾器將基包下的某些類納入或排除。Spring支持以下4種類型的過濾方式：

• 過濾器類型 表達式范例 說明
• 注解 org.example.SomeAnnotation 將所有使用SomeAnnotation注解的類過濾出來
• 類名指定 org.example.SomeClass 過濾指定的類
• 正則表達式 com\.kedacom\.spring\.annotation\.web\..* 通過正則表達式過濾一些類
• AspectJ表達式 org.example..*Service+ 通過AspectJ表達式過濾一些類

以正則表達式為例，我列舉一個應用實例：

	<context:component-scan base-package="com.casheen.spring.annotation">
		<context:exclude-filter type="regex" expression="com\.casheen\.spring\.annotation\.web\..*" />
	</context:component-scan>

值得注意的是<context:component-scan />配置項不但啟用了對類包進行掃描以實施注釋驅(qū)動Bean定義的功能，同時還啟用了注釋驅(qū)動自動注入的功能（即還隱式地在內(nèi)部注冊了AutowiredAnnotationBeanPostProcessor和CommonAnnotationBeanPostProcessor），因此當使用<context:component-scan />后，就可以將<context:annotation-config />移除了。 

2.3. 使用@Scope來定義Bean的作用范圍 
在使用XML定義Bean時，我們可能還需要通過bean的scope屬性來定義一個Bean的作用范圍，我們同樣可以通過@Scope注解來完成這項工作：

@Scope("session")
@Component()
public class UserSessionBean implements Serializable {
	...
}

3. 參考 
http://kingtai168.iteye.com/blog/244002 
http://www.iteye.com/topic/244153 
http://static.springframework.org/spring/docs/2.5.x/reference/beans.html#beans-annotation-config 
http://static.springframework.org/spring/docs/2.5.x/reference/beans.html#beans-classpath-scanning

 警告信息如下：

警告: No configuration found for the specified action: '/myNameSpace/login.action' in namespace: ''. Form action defaulting to 'action' attribute's literal value.

struts.xml配置信息（部分）

<package name="packageName" extends="struts-default" namespace="/myNameSpace">

    <action name="login" class="com.jato.srvclink.test.login.LoginAction" method="login">

jsp頁面配置信息（部分）

<s:form action="/myNameSpace/login.action">

思考：沒有在''的namespace中發(fā)現(xiàn)指定的action '/myNameSpace/login.action'

答疑：因為配置的struts2標簽并未指定namespace屬性。所以struts2會默認從根命名空間"/"搜索action串' /myNameSpace/login.action'，如果搜索不到將進入默認命名空間''搜索action請求串，在默認命名空間中是肯定找不到我們 定義的action的，所以，struts2拋出一個警告信息。

但是為什么我們沒有填寫namespace，我們的請求也可以正常訪問呢？

我們來看一下解析后的html

查看源碼得到的html（部分）

<form id="login" onsubmit="return true;" action="/srvclink/myNameSpace/login.action" method="post">

我們看到form提交的action串是準確的url請求，action串確實是/srvclin（應用根）/myNameSpace（命名空間）/login.action。

命名空間中找不到action定義，并不意味著這個action真的不存在，只是我們的代碼有問題而已。還有一點是我們在jsp頁面的action請求中 手動的加入了.action后綴。事實上struts2會自動追加.action的，因為我們并沒有合法的使用struts2的標簽，所以struts2 這里并沒有給我們追加.action，解析后的代碼中存在的.action，完全是我們手動在jsp頁面填寫的，有疑問的網(wǎng)友可以不手動添加查看 html。

我們修改我們的程序代碼

jsp頁面配置信息（部分）修改后加入namespace屬性，修改action屬性值為/login.action

<s:form action="/login.action" namespace="/myNameSpace">

請求頁面后，大家很失望吧？警告依然存在。但是我們看一下警告信息。

警告信息：

警告: No configuration found for the specified action: '/login.action' in namespace: '/myNameSpace'. Form action defaulting to 'action' attribute's literal value.

沒有在'/myNameSpace'的namespace中發(fā)現(xiàn)指定的action '/login.action'

毫無疑問，這里的警告和第一次的警告信息截然不同。我們現(xiàn)在存在命名空間，'/myNameSpace'能夠被struts2檢索到，并不是開始的''。那問題的關(guān)鍵在哪里呢？

在namespace中沒有發(fā)現(xiàn)指定的action '/login.action' ？？？

我們來看一下struts.xml中的配置：

struts.xml配置信息（部分）

<package name="packageName" extends="struts-default" namespace="/myNameSpace">

    <action name="login" class="com.jato.srvclink.test.login.LoginAction" method="login">

是的，我們'/myNameSpace'命名空間下，只有action名字為'login'的定義，并沒有所謂的'/login.action' 定義，所以struts2的警告并未錯。如果大家對這個抱有懷疑，可以修改action的名字'login'為‘/longin.action’

<action name="/login.action" class="com.jato.srvclink.test.login.LoginAction" method="login">

請求頁面時你會發(fā)現(xiàn)不在報警告信息，原因很簡單。因為在命名空間為'myNameSpace'下確實存在命名為'/login.action'的action。

我們再次修改配置文件

jsp頁面配置信息（部分）修改后action屬性值為longin

<s:form action="login" namespace="/myNameSpace">

請求頁面時，我們發(fā)現(xiàn)不再有警告信息了。

如果你有足夠細心，我想你應該可以徹底的明白為什么struts2會報警了吧？你也應該明白了使用struts2標簽action中添加/線后請求反而報錯的原因了。

  功能：本實例實現(xiàn)的功能是從輸入界面輸入用戶名和密碼，若用戶名和密碼正確轉(zhuǎn)到成功界面，否則轉(zhuǎn)到失敗界面。

   實現(xiàn)：
   第一步：創(chuàng)建一個Web工程
   在MyEclipse，通過菜單File->New->Web Project，在Project Name輸入工程名稱Strut2Travel，點解確定完成創(chuàng)建一個工程。
   簡注：MyEclipse屬于一個IDE繼承開發(fā)環(huán)境，可以快速的創(chuàng)建Web項目。讀者可以手工創(chuàng)建，只需滿足項目的文件結(jié)構(gòu)即可。其中WEB-INF文件夾必不可少。

   第二步：導入Struts2的核心支持包
   commons-fileupload-1.2.1.jar

   commons-io-1.3.2.jar

   commons-logging-1.0.4.jar

   freemarker-2.3.15.jar

   ognl-2.7.3.jar

   struts2-core-2.1.8.1.jar

   xwork-core-2.1.6.jar
   簡注：Struts2有大量的jar包，支持大量的功能，不同類型的應用可能需要不同的包支持。以上的5個包為Struts2的核心包，使用Struts2必須使用。

   第三步：配置struts2轉(zhuǎn)發(fā)過濾器
   編輯web.xml文件，添加以下內(nèi)容
 <filter>
  <filter-name>struts2</filter-name>
  <filter-class>
   org.apache.struts2.dispatcher.FilterDispatcher
  </filter-class>
 </filter>
 <filter-mapping>
  <filter-name>struts2</filter-name>
  <url-pattern>/*</url-pattern>
 </filter-mapping>
   簡注：“/*”表示涉及本工程的所有瀏覽器端的請求都經(jīng)過struts2過濾器處理。

    第四步：創(chuàng)建輸入頁面login.jsp、結(jié)果頁面welcome.jsp和error.jsp
login.jsp
<%@ page language="java" import="java.util.*" pageEncoding="GB2312"%>
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
<html>
  <head><title>登錄界面</title></head>
  <body>
    <form action="LoginAction.action">
       用戶名：<input name="username"><br>
       密 碼：<input type="password" name="userpass"><br>
      <input type="submit" value="提 交">
      <input type="reset"  value="取 消">
    </form>
  </body>
</html>

welcome.jsp
<%@ page language="java" import="java.util.*" pageEncoding="GB2312"%>
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
<html>
  <head>
    <title>歡迎</title>
  </head>
  <body>
    <font color="red" size="10">登錄成功！</font>
  </body>
</html>

error.jsp
<%@ page language="java" import="java.util.*" pageEncoding="GB2312"%>
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
<html>
  <head>
    <title></title>
  </head>
  <body>
    <font color="red" size="10">用戶或密碼錯誤！</font>
  </body>
</html>
    簡注：本實例是最簡單的應用，以上為純JSP文件，Struts2提供大量使用的標簽，本書后面的實例會使用到。

    第五步：創(chuàng)建Action文件LoginAction和struts2.xml文件
LoginAction.java
package com;

import com.opensymphony.xwork2.ActionSupport;

public class LoginAction extends ActionSupport{
 private String username;
 private String userpass;
 
 public String execute(){
  if("daniel".equals(username)&&"abcde".equals(userpass))
   return SUCCESS;
  else
   return ERROR;
 }
 
 public String getUsername() {
  return username;
 }
 public void setUsername(String username) {
  this.username = username;
 }
 public String getUserpass() {
  return userpass;
 }
 public void setUserpass(String userpass) {
  this.userpass = userpass;
 }
}

    簡注：默認配置情況下執(zhí)行execute()方法，實際應用中經(jīng)常更改配置。本書后面將深入講解。注意本類中的username和userpass必須和網(wǎng)頁文件的name屬性名一致。
struts.xml
<!DOCTYPE struts PUBLIC
        "-//Apache Software Foundation//DTD Struts Configuration 2.0//EN"
        "http://struts.apache.org/dtds/struts-2.0.dtd">
<struts>
 <package name="struts2demo" extends="struts-default">
   <action name="loginAction" class="com.LoginAction">
     <result name="success">/welcome.jsp</result>
     <result name="error">/error.jsp</result>
   </action>
 </package>  
</struts>

    第五步：將程序發(fā)布到Tomcat，啟動Tomcat即可。
    通過本實例讀者應該掌握如何配置并編寫一個最簡單最基本的應用，對于初學讀者以了解為主，沒必要深究一些問題。

Struts2教程1：第一個Struts2程序

在本系列教程中我們將學習到Struts2的各種技術(shù)。在本教程中使用的工具和程序庫的版本如下：

理解ActionContext 、ValueStack 、Stack Context
ActionContext
一次Action調(diào)用都會創(chuàng)建一個ActionContext
調(diào)用：ActionContext context = ActionContext.getContext()

ValueStack
由OGNL框架實現(xiàn)
可以把它簡單的看作一個棧（List） 。

Stack Object：放入stack中的對象，一般是action。
Stack Context（map）：stack上下文，它包含一系列對象，包括request/session/attr/application map等。
EL：存取對象的任意屬性，調(diào)用對象的方法，遍歷整個對象結(jié)…

ActionContext是Action上下文，可以得到request session application
ValueStack是值棧 存放表單中的值
Stack Context 棧上下文 也是用來存值的



struts2對OGNL上下文的概念又做了進一步擴充，在struts2中，OGNL上下文通常如下所示：

|--request 

| 

|--application 

| 

context map---|--OgnlValueStack(root) [ user, action, OgnlUtil, ... ] 

| 

|--session 

| 

|--attr 

| 

|--parameters




在Struts2中，采用標準命名的上下文(Context)來處理OGNL表達式。處理OGNL的頂級對象是一個Map（也叫context map），而OGNL在這個context中就是一個頂級對象(root)。在用法上，頂級對象的屬性訪問，是不需要任何標記前綴的。而其它非頂級的對象訪問，需要使用#標記。
Struts2框架把OGNL Context設置為我們的ActionContext。并且ValueStack作為OGNL的根對象。除value stack之外，Struts2框架還把代表application、session、request這些對象的Map對象也放到ActionContext中去。（這也就是Struts2建議在Action類中不要直接訪問Servlet API的原因，他可以通過ActionContext對象來部分代替這些（Servlet API）功能，以方便對Action類進行測試！）
Action的實例，總是放到value stack中。因為Action放在stack中，而stack是root(根對象)，所以對Action中的屬性的訪問就可以省略#標記。但是，要訪問ActionContext中其它對象的屬性，就必須要帶上#標記，以便讓OGNL知道，不是從根對象，而是從其它對象中去尋找。
那么訪問Action中的屬性的代碼就可以這樣寫

<s:property value="postalCode"/>
其它ActionContext中的非根對象屬性的訪問要像下面這樣寫：
<s:property value="#session.mySessionPropKey"/> or
<s:property value="#session['mySessionPropKey']"/> or
<s:property value="#request['myRequestPropKey']"/>
對Collection的處理，內(nèi)容就很簡單。
<s:select label="label" name="name" list="{'name1','name2','name3'}" value="%{'name2'}" />
這是處理List。這個代碼在頁面上建立一個下拉選項，內(nèi)容是list中的內(nèi)容，默認值是name2.
處理map

<s:select label="label" name="name" list="#{'foo':'foovalue', 'bar':'barvalue'}" />

需要注意的是，判斷一個值是否在collection中。我們要使用in或者not in來處理。
<s:if test="'foo' in {'foo','bar'}">
muhahaha
</s:if>
<s:else>
boo
</s:else>
另外，可以使用通配符來選擇collection對象的子集。
?——所有匹配選擇邏輯的元素
^——只提取符合選擇邏輯的第一個元素
$——只提取符合選擇邏輯的最后一個元素
person.relatives.{? #this.gender == 'male'}

?

?

值棧(ValueStack) 
Struts2將OGNL上下文設置為Struts2中的ActionContext(內(nèi)部使用的仍然是OgnlContext)，并將值棧設為OGNL的根對象。 
我們知道，OGNL上下文中的根對象可以直接訪問，不需要使用任何特殊的“標記”，而引用上下文中的其他對象則需要使用“#”來標記。由于值棧是上下文中的根對象，因此可以直接訪問。那么對于值棧中的對象該如何訪問呢？Struts2提供了一個特殊的OGNLPropertyAccessor，它可以自動查找棧內(nèi)的所有對象(從棧頂?shù)綏５?/span>)，直接找到一個具有你所查找的屬性的對象。也就是說，對于值棧中的任何對象都可以直接訪問，而不需要使用“#”。 
假設值棧中有兩個對象：student和employee，兩個對象都有name屬性，student有學號屬性number，而employee有薪水屬性salary。employee先入棧，student后入棧，位于棧頂，那么對于表達式name,訪問的就是student的name屬性，因為student對象位于棧頂；表達式salary，訪問的就是employee的salary屬性。正如你所見，訪問值棧中的對象屬性或方法，無須指明對象，也不用“#”，就好像值棧中的對象都是OGNL上下文中的根對象一樣。這就是Struts2在OGNL基礎上做出的改進。

 值棧中的Action實例 
Struts2框架總是把Action實例放在棧頂。因為Action在值棧中，而值棧又是OGNL中的根，所以引用Action的屬性可以省略“#”標記，這也是為什么我們在結(jié)果頁面中可以直接訪問Action的屬性的原因。

 Struts2中的命名對象 
Struts2還提供了一些命名對象，這些對象沒有保存在值棧中，而是保存在ActionContext中，因此訪問這些對象需要使用“#”標記。這些命名對象都是Map類型。 

parameters 
用于訪問請求參數(shù)。如：#parameters['id']或#parameters.id，相當于調(diào)用了HttpServletRequest對象的getParameter()方法。 
注意，parameters本質(zhì)上是一個使用HttpServletRequest對象中的請求參數(shù)構(gòu)造的Map對象，一量對象被創(chuàng)建(在調(diào)用Action實例之前就已經(jīng)創(chuàng)建好了)，它和HttpServletRequest對象就沒有了任何關(guān)系。 

request 
用于訪問請求屬性。如：#request['user']或#request.user，相當于調(diào)用了HttpServletRequest對象的getAttribute()方法。 

session 
用于訪問session屬性。如：#session['user']或#session.user，相當于調(diào)用了HttpSession對象的getAttribute()方法。 

application 
用于訪問application屬性。如：#application['user']或#application.user，相當于調(diào)用了ServletContext的getAttribute()方法。 

attr 
如果PageContext可用，則訪問PageContext，否則依次搜索request、session和application對象。

假設你的Action類中有變量String password; 要想獲取頁面中傳過來的password，必須為password設置get 和set 方法。當你的頁面進入Action時，ActionContext（Action上下文）通過set方法獲取password的值并壓入值棧棧頂，同時request也獲取到password的值，同時也如堆棧，session等對象的值也被壓入堆棧，ActionContext中的值在頁面中可以直接用<s:porperty value="password">取值顯示，而request中存儲的password通過<s:porperty value="#request.password">或者${password}取值。即struts是通過一個值棧來存儲所有對象和ActionContext中的值得。ActionContext為棧頂對象，也稱跟對象，ActionContext的值可以直接用變量名取，而其他的變量需要用#變量名取值。

1. 一、什么是OGNL，有什么特點？   
2.   
3. OGNL（Object-Graph Navigation Language），大概可以理解為：對象圖形化導航語言。是一種可以方便地操作對象屬性的開源表達式語言。OGNL有如下特點：    
4.   
5. 1、支持對象方法調(diào)用，形式如：objName.methodName()；   
6.   
7. 2、支持類靜態(tài)的方法調(diào)用和值訪問，表達式的格式為@[類全名（包括包路）]@[方法名 |  值名]，例如：   
8.   
9. @java.lang.String@format('foo %s', 'bar')或@tutorial.MyConstant@APP_NAME；   
10.   
11. 3、支持賦值操作和表達式串聯(lián)，例如：   
12.   
13. price=100, discount=0.8, calculatePrice()，這個表達式會返回80；   
14.   
15. 4、訪問OGNL上下文（OGNL context）和ActionContext；   
16.   
17. 5、操作集合對象。   
18.   
19.     
20.   
21. 二、使用OGNL表達式   
22.   
23. OGNL要結(jié)合struts標簽來使用。由于比較靈活，也容易把人給弄暈，尤其是“%”、“#”、“$”這三個符號的使用。由于$廣泛應用于EL中，這里重點寫%和#符號的用法。   
24.   
25. 1、“#”符號有三種用途：   
26.   
27. (1)、訪問非根對象（struts中值棧為根對象）如OGNL上下文和Action上下文，#相當于ActionContext.getContext()；下表有幾個ActionContext中有用的屬性：   
28.   
29.     
30.   
31. 名稱   
32.  作用   
33.  例子   
34.     
35. parameters   
36.  包含當前HTTP請求參數(shù)的Map   
37.  #parameters.id[0]作用相當于request.getParameter("id")    
38.     
39. request   
40.  包含當前HttpServletRequest的屬性（attribute)的Map   
41.  #request.userName相當于request.getAttribute("userName")    
42.     
43. session   
44.  包含當前HttpSession的屬性（attribute）的Map   
45.  #session.userName相當于session.getAttribute("userName")    
46.     
47. application   
48.  包含當前應用的ServletContext的屬性（attribute）的Map   
49.  #application.userName相當于application.getAttribute("userName")    
50.     
51.   
52. 注：attr 用于按request > session > application順序訪問其屬性（attribute），#attr.userName相當于按順序在以上三個范圍（scope）內(nèi)讀取userName屬性，直到找到為止。用于過濾和投影（projecting)集合，如books.{?#this.price<100}；構(gòu)造Map，如#{'foo1':'bar1', 'foo2':'bar2'}。   
53.   
54.     
55.   
56. (2)、用于過濾和投影（projecting)集合，如: books.{?#this.price>35}     
57.   
58. books.{?#this.price>35}   
59.   
60. (3)、構(gòu)造Map，如: #{'foo1':'bar1', 'foo2':'bar2'}     
61.   
62. #{'foo1':'bar1', 'foo2':'bar2'}這種方式常用在給radio或select、checkbox等標簽賦值上。如果要在頁面中取一個map的值可以這樣寫：    
63.   
64. <s:property value="#myMap['foo1']"/>     
65.   
66. <s:property value="#myMap['foo1']"/>   
67.   
68. 2、“%”符號的用途是在標簽的屬性值被理解為字符串類型時，告訴執(zhí)行環(huán)境%{}里的是OGNL表達式。   
69.   
70. 這是一開始最讓我不能理解的符號，原因是一些相關(guān)資源在表述時不太準備，經(jīng)過一翻痛苦的探索，終于明白了它的用途。實際上就是讓被理解為字符串的表達式，被真正當成ognl來執(zhí)行。很有點類似javascript里面的eval_r()功能，例如 ：   
71.   
72. var oDiv = eval_r("document.all.div"+index)     
73.   
74. var oDiv = eval_r("document.all.div"+index)   
75.   
76. 當index變量為1時，語句就會被當作var oDiv = document.all.div1  var oDiv = document.all.div1來執(zhí)行。%{}就是起這個作用。舉例：    
77.   
78. <s:set name="myMap" value="#{'key1':'value1','key2':'value2'}"/>      
79.   
80. <s:property value="#myMap['key1']"/>      
81.   
82. <s:url value="#myMap['key1']" />    
83.   
84. <s:set name="myMap" value="#{'key1':'value1','key2':'value2'}"/>   
85.   
86. <s:property value="#myMap['key1']"/>   
87.   
88. <s:url value="#myMap['key1']"/>   
89.   
90. 上面的代碼第2行會在頁面上輸出“value1”，而第3行則會輸出"#myMap['key1']"這么一個字符串。 如果將第3行改寫成這樣：    
91.   
92. <s:url value="%{#myMap['key1']}"/>     
93.   
94. <s:url value="%{#myMap['key1']}"/>   
95.   
96. 則輸出為“value1”。   
97.   
98.     
99.   
100.     
101.   
102. 這說明struts2里不同的標簽對ognl的表達式的理解是不一樣的。如果當有的標簽“看不懂”類似“#myMap['key1']”的語句時，就要用%{}來把這括進去，“翻譯”一下了。   
103.   
104. 3、“$”有兩種用途   
105.   
106. (1)、在國際化資源文件中，引用OGNL表達式。   
107.   
108. (2)、在Struts 2配置文件中，引用OGNL表達式：    
109.   
110. <action name="saveUser" class="userAction" method="save">   
111.   
112. <result type="redirect">listUser.action?msg=${msg}</result>   
113.   
114. </action>   
115.   
116. <action name="saveUser" class="userAction" method="save">       
117.   
118. <result type="redirect">listUser.action?msg=${msg}</result>   
119.   
120. </action>  
     

一般情況下，URL 中的參數(shù)應使用 url 編碼規(guī)則，即把參數(shù)字符串中除了 -_. 之外的所有非字母數(shù)字字符都將被替換成百分號（%）后跟兩位十六進制數(shù)，空格則編碼為加號（+）。但是對于帶有中文的參數(shù)來說，這種編碼會使編碼后的字符串變得很長。如果希望有短一點的方式對參數(shù)編碼，可以采用 base64 編碼方式對字符串進行編碼，但是 base64 編碼方式不能處理 JavaScript 中的中文，因為 JavaScript 中的中文都是以 UTF-16 方式保存的。而 base64 只能處理單字節(jié)字符，所以不能直接用 base64 對帶有中文的 JavaScript 字符串進行編碼。但是可以通過 utf.js 這個程序中提供的 utf16to8 來將 UTF-16 編碼的中文先轉(zhuǎn)化為 UTF-8 方式，然后再進行 base64 編碼。這樣編碼后的字符串，在傳遞到服務器端后可以直接通過 base64_decode 解碼成 UTF-8 的中文字符串。但是還有個問題需要注意。base64 編碼中使用了加號（+），而 + 在 URL 傳遞時會被當成空格，因此必須要將 base64 編碼后的字符串中的加號替換成 %2B 才能當作 URL 參數(shù)進行傳遞。否則在服務器端解碼后就會出錯。

所以我們需要做的就是：
js中：encodeURI(str).replace(/\+/g,'%2B')
java中：str.replaceAll("\\+","%2B")