(spring-第4回【IoC基礎篇】)spring基於注解的配置

基於XML的bean屬性配置：bean的定義信息與bean的實現類是分離的。

基於注解的配置：bean的定義信息是通過在bean實現類上標注注解實現。

也就是說，加了注解，相當於在XML中配置了，一樣一樣的。

 

一、舉個栗子：

package com.mesopotamia.annotation;

import org.springframework.stereotype.Component;

@Component
public class Car {
    private String name;
    private String color;
    private double price;
    public Car(){
        name="保時捷";
        color="黃色";
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public String getColor() {
        return color;
    }
    public void setColor(String color) {
        this.color = color;
    }
    public double getPrice() {
        return price;
    }
    public void setPrice(double price) {
        this.price = price;
    }

    public String toString(){
        return "名字："+name+" 顏色："+color+" 價格："+price;
    }
}

 

第5行標注Component：spring看到這個屬性標志，會自動將Car變成容器管理類，等同於在XML中這樣配置：

<bean id="car" class="com.mesopotamia.annotation.Car"></bean>

 

二、spring啟動之前的配置？

 

<?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"
         >
   <context:component-scan base-package="com.mesopotamia.annotation"/>
</beans>

 

如上，

使用空間：context，

使用context的規則：component-scan.

第10行的意義：掃描這個包中的所有類，並從注解信息中獲取bean的基本信息(沒加注解的不掃描也不實例化)。

 

三、如何啟動？

 

按正常方式啟動即可加載（自己復習spring容器的加載），例如：

package com.mesopotamia.annotation;

import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class Main {
    
    public static void main(String args[]){
        ApplicationContext ctx = new ClassPathXmlApplicationContext("com/mesopotamia/annotation/beans.xml");
        Car car= ctx.getBean(Car.class);
        System.out.println(car.toString());
    }

}

第10行就已經實例化Car了，並且實例化之前先跑了Car的構造函數給car的屬性附了值（因為我給構造函數里專門寫了賦值語句，沒寫的話，屬性是沒有賦值的，除非見了鬼）。

下面是打印信息，從下面第4行結果可以看到已經附了值。

2015-11-13 23:44:18,414  INFO [main] (AbstractApplicationContext.java:456) - Refreshing org.springframework.context.support.ClassPathXmlApplicationContext@e80a59: startup date [Fri Nov 13 23:44:18 CST 2015]; root of context hierarchy
2015-11-13 23:44:18,480  INFO [main] (XmlBeanDefinitionReader.java:315) - Loading XML bean definitions from class path resource [com/mesopotamia/annotation/beans.xml]
2015-11-13 23:44:18,728  INFO [main] (DefaultListableBeanFactory.java:555) - Pre-instantiating singletons in org.springframework.beans.factory.support.DefaultListableBeanFactory@121ab80: defining beans [car,org.springframework.context.annotation.internalConfigurationAnnotationProcessor,org.springframework.context.annotation.internalAutowiredAnnotationProcessor,org.springframework.context.annotation.internalRequiredAnnotationProcessor,org.springframework.context.annotation.internalCommonAnnotationProcessor,org.springframework.context.annotation.internalPersistenceAnnotationProcessor]; root of factory hierarchy
名字：保時捷 顏色：黃色 價格：0.0

 

四、context:component-scan的配置直接選了相應包里的全部class，有沒有更多的過濾方式？

 

有。context:component-scan標簽下面可以再加子標簽，如：

<context:component-scan base-package="com.baobaotao">
       <context:include-filter type="aspectj" expression="com.baobaotao.anno.*Plugin+"/>
       <context:exclude-filter type="regex" expression="cn\.outofmemory\.spring\.[^.]+(Dao|Service)"/>
</context:component-scan>

include-filter表示：包含哪些。type是類型，expression是表達式過濾。

exclude-filter表示：除去哪些。type是類型，expression是表達式過濾。

第二行表示：com.baobaotao.anno包下面所有以Plugin結尾的class。

第三行表示：除去所有以Dao或者Service結束的類。具體規則這里先不作討論，你要覺得你行，那你自己先啃啃里面的肉（先去復習一下正則表達式）

其他過濾表達式舉例：

 

五、除了Component外，其他的注解都有什么？

 

1、@Component 一般的bean類上面配置。

2、@Controller 對應表現層的Bean，也就是action。

3、@ Service 對應業務層bean。

4、@ Repository 對應持久層Bean。

上面的4種起到相同的效果，都是注入bean，注入bean的四大金剛，張龍趙虎王朝馬漢，輔佐包黑炭。

 

5、@Autowired 成員變量或方法入參處標注，按類型匹配自動注入。

6、@Qualifier 按名稱匹配方式注入。

7、@PostConstruct指定初始化方法。（相當於XML配置中的init-method）

8、@PreDestroy指定銷毀方法。(相當於XML配置中的destroy-method)

9、@Scope 指定bean是prototype還是singleton。

 

六、上面這幾個注解給個具體例子說明下？

 

 不想往下看的可以去陪女朋友了，因為重點已經講完了。下面是一個簡單登錄界面的栗子，為了突出重點，關於spring web方面的機制暫時不講，只講有關注解的部分，如果你還沒看過spring web應用部分也無妨，下面的例子只涉及注解注入部分：

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:p="http://www.springframework.org/schema/p"
    xmlns:context="http://www.springframework.org/schema/context"
    xmlns:aop="http://www.springframework.org/schema/aop" 
    xmlns:tx="http://www.springframework.org/schema/tx"
    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
       http://www.springframework.org/schema/tx 
       http://www.springframework.org/schema/tx/spring-tx-3.0.xsd
       http://www.springframework.org/schema/aop
       http://www.springframework.org/schema/aop/spring-aop-3.0.xsd">
    
    <!-- 掃描類包，將標注Spring注解的類自動轉化Bean，同時完成Bean的注入 -->
    <context:component-scan base-package="com.baobaotao.dao"/>
    <context:component-scan base-package="com.baobaotao.service"/>
    <context:component-scan base-package="com.baobaotao.domain"/>
    
    <!-- 配置數據源 -->
    <bean id="dataSource" class="org.apache.commons.dbcp.BasicDataSource"
        destroy-method="close" 
        p:driverClassName="com.mysql.jdbc.Driver"
        p:url="jdbc:mysql://localhost:3306/sampledb" 
        p:username="root"
        p:password="2009118293zjl" />

    <!-- 配置Jdbc模板  -->
    <bean id="jdbcTemplate" class="org.springframework.jdbc.core.JdbcTemplate"
        p:dataSource-ref="dataSource" />
        
    <!-- 配置事務管理器 -->
    <bean id="transactionManager"
        class="org.springframework.jdbc.datasource.DataSourceTransactionManager"
        p:dataSource-ref="dataSource" />
        
    <!-- 通過AOP配置提供事務增強，讓service包下所有Bean的所有方法擁有事務 -->
    <aop:config proxy-target-class="true">
        <aop:pointcut id="serviceMethod"
            expression=" execution(* com.baobaotao.service..*(..))" />
        <aop:advisor pointcut-ref="serviceMethod" advice-ref="txAdvice" />
    </aop:config>
    <tx:advice id="txAdvice" transaction-manager="transactionManager">
        <tx:attributes>
            <tx:method name="*" />
        </tx:attributes>
    </tx:advice>
</beans>

重點第18到20行：spring只掃描配置路徑下所有帶注解的地方來注入相關數據。其他行先不看，你想看我也不攔你。

WEB應用后台java分三層：control、service、dao層，簡單講一下，直接與jsp交互的就是control層，直接操作數據庫的是dao層(持久層，數據庫里的數據都是持久性的嘛)，service層負責把dao層數據拿到，經過處理，返回給control層。control層拿到數據再交給jsp前台。（dao就是程序員，service就是老板，control就是客戶，程序員做東西，客戶使用，而老板是橋梁）

 

下面是control層：

package com.baobaotao.web;

import java.util.Date;

import javax.annotation.PostConstruct;
import javax.annotation.PreDestroy;
import javax.servlet.http.HttpServletRequest;


import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.servlet.ModelAndView;

import com.baobaotao.domain.User;
import com.baobaotao.service.UserService;

@Controller
public class LoginController{
    Log log=LogFactory.getLog(LoginController.class);
    
    @Autowired(required=false)
    private UserService userService;
   
    @RequestMapping(value = "/loginCheck.do")
    public ModelAndView loginCheck(HttpServletRequest request,LoginCommand loginCommand){
        boolean isValidUser = userService.hasMatchUser(loginCommand.getUserName(),loginCommand.getPassword());
        if (!isValidUser) {
            return new ModelAndView("login", "error", "用戶名或密碼錯誤。");
        } else {
            User user = userService.findUserByUserName(loginCommand
                    .getUserName());
            user.setLastIp(request.getLocalAddr());
            user.setLastVisit(new Date());
            userService.loginSuccess(user);
            request.getSession().setAttribute("user", user);
            
            return new ModelAndView("main");
        }
    }
    
    @PostConstruct
    public void init(){
        log.info("本應用程序正式拉開帷幕。。。");
    }
    
    @PreDestroy
    public void destroy(){
        log.info("本應用程序正式落幕，嚇嚇儂。。。");
    }
}

這里用到了幾個注解，

spring看到@Controller會如同看到@Component一樣，轉換成spring容器管理的bean。

spring看到@Autowired(required=false)會自動注入（實例化）下面的userService。（直接用就行，就不用你來new一個對象啦）。

spring看到@PostConstruct就會在實例化本Bean后接着執行這個方法；

spring看到@PreDestroy就會在銷毀之前執行下面的方法；

你的眼神告訴我你不相信我。好的，咱們看日志：

tomcat啟動的時候spring容器會自動加載，下面是tomcat啟動的日志：

。。。。。。

2015-11-15 21:24:31,673 DEBUG [main] (DefaultSingletonBeanRegistry.java:214) - Creating shared instance of singleton bean 'userDao'
2015-11-15 21:24:31,674 DEBUG [main] (AbstractAutowireCapableBeanFactory.java:430) - Creating instance of bean 'userDao'
2015-11-15 21:24:31,674 DEBUG [main] (AbstractBeanFactory.java:242) - Returning cached instance of singleton bean 'org.springframework.aop.support.DefaultBeanFactoryPointcutAdvisor#0'

。。。。。。

2015-11-15 21:24:31,676 DEBUG [main] (InjectionMetadata.java:82) - Processing injected method of bean 'userDao': AutowiredFieldElement for private org.springframework.jdbc.core.JdbcTemplate com.baobaotao.dao.UserDao.jdbcTemplate
2015-11-15 21:24:31,677 DEBUG [main] (AbstractBeanFactory.java:242) - Returning cached instance of singleton bean 'jdbcTemplate'
2015-11-15 21:24:31,677 DEBUG [main] (AutowiredAnnotationBeanPostProcessor.java:420) - Autowiring by type from bean name 'userDao' to bean named 'jdbcTemplate'

。。。。。。

2015-11-15 21:24:31,678 DEBUG [main] (AbstractAutowireCapableBeanFactory.java:458) - Finished creating instance of bean 'userDao'


。。。。。。

2015-11-15 21:24:31,679 DEBUG [main] (DefaultSingletonBeanRegistry.java:214) - Creating shared instance of singleton bean 'userService'
2015-11-15 21:24:31,679 DEBUG [main] (AbstractAutowireCapableBeanFactory.java:430) - Creating instance of bean 'userService'
2015-11-15 21:24:31,679 DEBUG [main] (AbstractBeanFactory.java:242) - Returning cached instance of singleton bean 'org.springframework.aop.support.DefaultBeanFactoryPointcutAdvisor#0'
2015-11-15 21:24:31,680  INFO [main] (UserService.java:18) - 實例化了UserService... 24 
。。。。。。

2015-11-15 21:24:31,683 DEBUG [main] (InjectionMetadata.java:82) - Processing injected method of bean 'userService': AutowiredFieldElement for private com.baobaotao.dao.UserDao com.baobaotao.service.UserService.userDao
2015-11-15 21:24:31,685 DEBUG [main] (AbstractBeanFactory.java:242) - Returning cached instance of singleton bean 'userDao'
2015-11-15 21:24:31,685 DEBUG [main] (AutowiredAnnotationBeanPostProcessor.java:420) - Autowiring by type from bean name 'userService' to bean named 'userDao'
2015-11-15 21:24:31,686 DEBUG [main] (InjectionMetadata.java:82) - Processing injected method of bean 'userService': AutowiredFieldElement for private com.baobaotao.dao.LoginLogDao com.baobaotao.service.UserService.loginLogDao
2015-11-15 21:24:31,686 DEBUG [main] (AbstractBeanFactory.java:242) - Returning cached instance of singleton bean 'loginLogDao'
2015-11-15 21:24:31,687 DEBUG [main] (AutowiredAnnotationBeanPostProcessor.java:420) - Autowiring by type from bean name 'userService' to bean named 'loginLogDao'

。。。。。。

2015-11-15 21:24:32,093  INFO [main] (UserService.java:18) - 實例化了UserService... 37 2015-11-15 21:24:32,094 DEBUG [main] (AbstractAutowireCapableBeanFactory.java:458) - Finished creating instance of bean 'userService'
2015-11-15 21:24:32,094 DEBUG [main] (DefaultSingletonBeanRegistry.java:214) - Creating shared instance of singleton bean 'loginLog'

。。。。。。

015-11-15 21:24:32,252  INFO [main] (DefaultListableBeanFactory.java:555) - Pre-instantiating singletons in org.springframework.beans.factory.support.DefaultListableBeanFactory@c272bc: defining beans [loginController,org.springframework.context.annotation.internalConfigurationAnnotationProcessor,org.springframework.context.annotation.internalAutowiredAnnotationProcessor,org.springframework.context.annotation.internalRequiredAnnotationProcessor,org.springframework.context.annotation.internalCommonAnnotationProcessor,org.springframework.web.servlet.view.InternalResourceViewResolver#0]; parent: org.springframework.beans.factory.support.DefaultListableBeanFactory@691dee
2015-11-15 21:24:32,252 DEBUG [main] (DefaultSingletonBeanRegistry.java:214) - Creating shared instance of singleton bean 'loginController'
2015-11-15 21:24:32,254 DEBUG [main] (AbstractAutowireCapableBeanFactory.java:430) - Creating instance of bean 'loginController'
2015-11-15 21:24:32,255  INFO [main] (LoginController.java:25) - 實例化了LoginController... 46 2015-11-15 21:24:32,264 DEBUG [main] (InitDestroyAnnotationBeanPostProcessor.java:200) - Found init method on class [com.baobaotao.web.LoginController]: public void com.baobaotao.web.LoginController.init() 47 2015-11-15 21:24:32,265 DEBUG [main] (InitDestroyAnnotationBeanPostProcessor.java:208) - Found destroy method on class [com.baobaotao.web.LoginController]: public void com.baobaotao.web.LoginController.destroy() 48 2015-11-15 21:24:32,265 DEBUG [main] (InitDestroyAnnotationBeanPostProcessor.java:251) - Found init method on class [com.baobaotao.web.LoginController]: org.springframework.beans.factory.annotation.InitDestroyAnnotationBeanPostProcessor$LifecycleElement@316510
2015-11-15 21:24:32,265 DEBUG [main] (InitDestroyAnnotationBeanPostProcessor.java:259) - Found destroy method on class [com.baobaotao.web.LoginController]: org.springframework.beans.factory.annotation.InitDestroyAnnotationBeanPostProcessor$LifecycleElement@5cd39ffa
2015-11-15 21:24:32,266 DEBUG [main] (InjectionMetadata.java:59) - Found injected element on class [com.baobaotao.web.LoginController]: AutowiredFieldElement for private com.baobaotao.service.UserService com.baobaotao.web.LoginController.userService 51 2015-11-15 21:24:32,267 DEBUG [main] (AbstractAutowireCapableBeanFactory.java:504) - Eagerly caching bean 'loginController' to allow for resolving potential circular references
2015-11-15 21:24:32,268 DEBUG [main] (InjectionMetadata.java:82) - Processing injected method of bean 'loginController': AutowiredFieldElement for private com.baobaotao.service.UserService com.baobaotao.web.LoginController.userService
2015-11-15 21:24:32,269 DEBUG [main] (AbstractBeanFactory.java:242) - Returning cached instance of singleton bean 'userService'
2015-11-15 21:24:32,270 DEBUG [main] (AutowiredAnnotationBeanPostProcessor.java:420) - Autowiring by type from bean name 'loginController' to bean named 'userService'
2015-11-15 21:24:32,271 DEBUG [main] (InitDestroyAnnotationBeanPostProcessor.java:291) - Invoking init method on bean 'loginController': public void com.baobaotao.web.LoginController.init() 56 2015-11-15 21:24:32,271  INFO [main] (LoginController.java:50) - 本應用程序正式拉開帷幕。。。 57 2015-11-15 21:24:32,271 DEBUG [main] (AbstractAutowireCapableBeanFactory.java:458) - Finished creating instance of bean 'loginController'

。。。。。。

第44、45行是實例化LoginController，

第46/47行是根據@PostContruct和@PreDestroy發現了我們定義的初始化和銷毀方法。

第53行，spring直接給了我們一個userService對象（因為它看到了@Autowired，required=false是說如果找不到對應的bean不報異常）。

第56行，spring看到@PostContruct執行了初始化方法。

當我把tomcat停掉，spring容器就會銷毀，那么是不是要執行@PreDestroy下面的銷毀方法？當然，你要相信科學，看停掉tomcat的日志：

。。。。。
2015-11-15 21:53:15,763 DEBUG [main] (InitDestroyAnnotationBeanPostProcessor.java:303) - Invoking destroy method on bean 'loginController': public void com.baobaotao.web.LoginController.destroy()
2015-11-15 21:53:15,763  INFO [main] (LoginController.java:55) - 本應用程序正式落幕，嚇嚇儂。。。 7 2015-11-15 21:53:15 org.apache.catalina.core.ApplicationContext log
信息: Closing Spring root WebApplicationContext
2015-11-15 21:53:15,764  INFO [main] (AbstractApplicationContext.java:1002) - Closing Root WebApplicationContext: startup date [Sun Nov 15 21:24:29 CST 2015]; root of context hierarchy

第六行果然執行了銷毀方法。

請解釋前面那個日志里第53行的Returning cached instance of singleton bean 'userService'。

是這樣的，先看UserService的部分代碼：

@Service
public class UserService {
    private static Log log=LogFactory.getLog(UserService.class);
    public UserService(){
        log.info("實例化了UserService...");
    }

我在這個類中注釋了@Service，spring在啟動的時候跟@Component、@Controller、@Repository一樣，會自動把bean信息注入容器中(即把bean在spring容器中實例化)，也就是說，當spring看到@Service時，會自動返回一個提前實例化好的UserService，而只要UserService上面不顯式標注：@Scope("prototype"),那么默認UserService就是單例模式的。單例模式下，spring會把bean放到IoC容器的緩存池中，而把bean的引用返回給調用者。這就是Returning cached instance of singleton bean 'userService'這句話的意義。

好的，我把UserService的注解改成下面的方式：

@Service
@Scope("prototype")
public class UserService {
    private static Log log=LogFactory.getLog(UserService.class);
    public UserService(){
        log.info("實例化了UserService...");
    }
    

那么啟動tomcat打印日志如下：

2015-11-15 22:11:09,723 DEBUG [main] (Cglib2AopProxy.java:755) - Method is declared on Advised interface: public abstract int org.springframework.aop.framework.Advised.indexOf(org.aopalliance.aop.Advice)
2015-11-15 22:11:09,724 DEBUG [main] (Cglib2AopProxy.java:755) - Method is declared on Advised interface: public abstract int org.springframework.aop.framework.Advised.indexOf(org.springframework.aop.Advisor)
2015-11-15 22:11:09,724 DEBUG [main] (Cglib2AopProxy.java:755) - Method is declared on Advised interface: public abstract java.lang.Class org.springframework.aop.TargetClassAware.getTargetClass()
2015-11-15 22:11:09,760  INFO [main] (UserService.java:20) - 實例化了UserService...  5 2015-11-15 22:11:09,760 DEBUG [main] (AbstractAutowireCapableBeanFactory.java:458) - Finished creating instance of bean 'userService'
2015-11-15 22:11:09,761 DEBUG [main] (AutowiredAnnotationBeanPostProcessor.java:420) - Autowiring by type from bean name 'loginController' to bean named 'userService'
2015-11-15 22:11:09,761 DEBUG [main] (InitDestroyAnnotationBeanPostProcessor.java:291) - Invoking init method on bean 'loginController': public void com.baobaotao.web.LoginController.init()
2015-11-15 22:11:09,761  INFO [main] (LoginController.java:50) - 本應用程序正式拉開帷幕。。。  9 2015-11-15 22:11:09,761 DEBUG [main] (AbstractAutowireCapableBeanFactory.java:458) - Finished creating instance of bean 'loginController'
2015-11-15 22:11:09,761 DEBUG [main] (AbstractBeanFactory.java:242) - Returning cached instance of singleton bean 'org.springframework.context.annotati

你會看到，在拉開帷幕之前，又實例化了一次UserService,這就是prototype的作用。

再看：

@Controller
public class LoginController{
    Log log=LogFactory.getLog(LoginController.class);
    
    public LoginController(){
        log.info("實例化了LoginController...");
    }
    
    @Autowired(required=false)
    @Qualifier("service")
    private UserService userService;
   

第10行，我在userService上面加了 @Qualifier("service")的注釋，這個表示，我引用的是名字為service的bean的實例，那么你要給UserService起個名字叫service：

@Service("service")
@Scope("prototype")
public class UserService {
    private static Log log=LogFactory.getLog(UserService.class);
    public UserService(){
        log.info("實例化了UserService...");
    }
    

像第一行那樣。（Component、Controller、Repository也是那樣命名，如果是基於XML的注入如何命名？自己復習去。）

不加的話，系統找不到對應的bean，就會報錯。

 

spring容器的三座大山：XML配置文件（或者注解配置、bean配置等），spring容器，bean類。不管是基於XML還是基於注解，無非就是為了把bean信息注入到spring容器中，南拳和北腿，各有千秋。下面是二者的對比：

本節內容就講到這里。

 

 

 

吾生也有涯，而知也無涯。

　　　　　　　　　　　　——《庄子》