Spring bean的幾種裝配方式

本文轉載自查看原文 2019-04-04 11:54 625

　　對象的個數，對象創建的時機

一 bean的裝配(xml方式1)

1.對象創建：單例、多例

　　scope="singleton" 默認值單例

　　scope="prototype",多例

2.什么時候創建

　　scope="prototype" 在使用到對象時，才創建對象

　　scope="singleton" 在啟動（容器初始化之前），創建bean，整個應用只有一個對象

3.是否延遲加載

　　lazy-init="default" 默認為false不延遲，啟動時創建

　　lazy-init="true" 延遲，啟動時不創建，使用時創建

4.創建對象之后的初始化與銷毀

　　init-method ="對象自定義的init方法名稱"

　　destroy-method="對象自定義的destroy方法名稱"

在applicationContext.xml文件中

(此處還沒有用到p-namespace，后面會介紹。介紹p-namespace之前，applicationContext的頭部都如下所示，在使用p-namespace是后增加一個xmlns:p="http://www.springframework.org/schema/p")

<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" 
       xsi:schemaLocation="http://www.springframework.org/schema/beans
      http://www.springframework.org/schema/beans/spring-beans-3.2.xsd>

<!--1.無參構造-->
<!--單例模式，默認的設置，在加載容器之前bean中的對象就會被創建-->
<bean id="user1",class="XXX.User" scope="singleton">
<!--多例模式，在加載容器之后，bean中的對象才會被創建,不管是否調用applictionContext.getBean()-->
<bean id="user2",class="XXX.User" scope="prototype">
<!--多例模式延遲加載，在調用applictionContext.getBean()之后，對象才會被創建-->
<bean id="user3",class="XXX.User" scope="prototype" lazy-init="true">

</beans>

class User{
    private int id;
    private String name;
    public User(){
    }
    public User(int id,String name){
    this.id=id;
    this.name=name;
    }
  public void initUser(){
  System.out.println("初始化");
  }  
  public void destroyUser(){
  System.out.println("對象銷毀");
  }  

//get and set

//toString()
}

class UserFactory{
    public User getInstance(){
        return new User();
    }

    public static User getStaticInstance(){
        return new User();
    }
}

二、bean的裝配(xml方式2)

Spring IOC容器

　　Spring IOC容器：是Spring的核心內容

　　作用：創建對象，處理對象的依賴關系

　　IOC容器創建對象

　　幾種方式：

　　1.調用無參構造

　　2.帶參數構造

　　3.工廠創建對象

　　　　工廠類：靜態方法創建對象

　　　　　　　　非靜態方法創建對象

<!--1.無參構造-->
<!--單例模式，默認的設置，在加載容器之前bean中的對象就會被創建-->
<bean id="user1",class="XXX.User" scope="singleton">
<!--多例模式，在加載容器之后，bean中的對象才會被創建,不管是否調用applictionContext.getBean()-->
<bean id="user2",class="XXX.User" scope="prototype">
<!--多例模式延遲加載，在調用applictionContext.getBean()之后，對象才會被創建-->
<bean id="user3",class="XXX.User" scope="prototype" lazy-init="true">

<!--2.參數構造-->
<bean id="str" calss="java.lang.String">
    <constructor-arg   value="Tom" ></constructor-arg>
</bean>
<bean id="user4" calss="java.lang.String">
    <constructor-arg index="0" value="998" type="int"></constructor-arg>
    <constructor-arg index="1" ref="s"></constructor-arg>
</bean>


<!--3.工廠模式創建對象 -->
<!--工廠模式創建對象，使用非靜態方法-->
<bean id="factory",class="XXX.UserFactory" >
<bean id="user5"，factory-bean="factory" factory-method="getInstance">

<!--工廠模式創建對象，使用靜態方法-->
<bean id="user6"，calss="XXX.UserFactory" factory-method="getStaticInstance">

三、bean的裝配(xml方式3)

　　對象依賴關系

　　DI,依賴注入

　　1.通過構造

　　2.通過set方法對屬性注入

　　3.p名稱空間

　　4.自動裝配

<!--1.參數構造-->
<bean id="user1" calss="xxx.User">
    <constructor-arg index="0" value="998" type="int"></constructor-arg>
    <constructor-arg index="1" value="Tom" type="java.lang.String"></constructor-arg>
</bean>

<bean id="str" calss="java.lang.String">
    <constructor-arg   value="Tom" ></constructor-arg>
</bean>
<bean id="user2" calss="xxx.User">
    <constructor-arg index="0" value="998" type="int"></constructor-arg>
    <constructor-arg index="1" ref="s"></constructor-arg>
</bean>

<!--2.通過set方法對屬性注入-->
<bean id="user3" calss="xxx.User">
    <property name="id" value="998"></property>
    <property name="name" value="Tom "></property>
</bean>

Controller/Service/Dao開發

java類

class Test{
    
    public static void main(String[] args){
        ApplicationContext applicationContext=new ClassPathXmlApplicationContext("applicationContext.xml");//注意文件的路徑
        UserAction userAction=(UserAction) applicationContext.getBean("userAction");
        userAction.adddUser();
    }
}

//UserController.java
class UserController{

    UserService userService;

    private void setUserService(UserService userService){
        this.userService=userService;
    }

    private void addUser(){
        userService.save();
    }
}

//UserService.java
class UserService {

    private UserDao userDao;

    private void setUserDao (UserDao userDao){
        this.userDao=userDao;
    }

    private void save(){
        userDao.save();
    }
}

//UserDao .java
class UserDao {

    public void save(){
       System.out.println("正在保存");
    }
}

注入controller、service、dao方式1

applicationContext.xml文件


<!--  Controller -->
<bean id="userController" calss="xxx.UserController">
    <property name="userService" ref="userService"></property>
</bean>

<!--  Service -->
<bean id="userService " calss="xxx.UserService r">
    <property name="userDao" ref="userDao"></property>
</bean>

<!--  Dao -->
<bean id="userDao" calss="xxx.UserDao">
</bean>

注入controller、service、dao方式2
applicationContext.xml文件

<!--  Controller -->
<bean id="userController2" calss="xxx.UserController">
    <property name="userService" >
        <bean calss="xxx.UserService></bean>
            <property name="userDao" >
                <bean calss="xxx.UserDao></bean>
            </property>
    </property>
</bean>

開始介紹p-namespace

<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"

       xsi:schemaLocation="http://www.springframework.org/schema/beans
      http://www.springframework.org/schema/beans/spring-beans-3.2.xsd>

    <!--以前的方式-->
    <!--
    <bean id="user" class="xxx.User">
        <property name="id" value ="998"></property>
    </bean>
    -->


    <!--使用p-namespace的方式-->
    <bean id="user" class="xxx.User" p:id="998" p:name="Tom"></bean>

    <bean id="userDao" class="xxx.UserDao"  ></bean>
    <bean id="userService" class="xxx.UserService" p:userDao-ref="userDao"></bean>            
    <bean id="userController" class="xxx.UserController" p:userService-ref="userService"></bean>
</beans>

自動裝配

a.根據名稱、類型自動裝配

autowire="byName"；自動ioc容器中去找與屬性名同名的對象，自動注入

autowire="byType" IOC容器中只有一個該類型的對象，按照類型匹配，名字與屬性名不同也可以匹配。
　　　　　　　　　　　　但是注意這種情況，有兩個bean實現同一個接口，自動按照類型裝配會找不到到底是哪一個，就會報錯

b.定義全局

<beans 
　　......
　　default-autowire="byName">
......
</beans>

<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"

       xsi:schemaLocation="http://www.springframework.org/schema/beans
      http://www.springframework.org/schema/beans/spring-beans-3.2.xsd>

    <!--自動裝配 autowire="byName" autowire="byType"-->
<!--根據名稱自動匹配autowire="byName"；自動ioc容器中去找與屬性名同名的對象，自動注入-->
    <bean id="user" class="xxx.User" p:id="998" p:name="Tom"></bean>

    <bean id="userDao" class="xxx.UserDao"  ></bean>
    <bean id="userService" class="xxx.UserService" autowire="byName"></bean>            
    <bean id="userController" class="xxx.UserController" autowire="byType"></bean>
</beans>

<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"

       xsi:schemaLocation="http://www.springframework.org/schema/beans
      http://www.springframework.org/schema/beans/spring-beans-3.2.xsd default-autowire="byName">

<!--所有默認根據名稱自動匹配default-autowire="byName"-->
    <bean id="user" class="xxx.User" p:id="998" p:name="Tom"></bean>

    <bean id="userDao" class="xxx.UserDao"  ></bean>
    <bean id="userService" class="xxx.UserService"></bean>            
    <bean id="userController" class="xxx.UserController"></bean>
</beans>

四、bean的裝配(注解)

可以簡化Sping IOC容器的配置

在applicationcontext.xml文件，必須引入xmlns=context="http://www.springframework.org/schema/context"

在xsi=schemaLocation需要說明一下

<!--引入context名稱空間-->

<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"

       xsi:schemaLocation="http://www.springframework.org/schema/beans
      http://www.springframework.org/schema/beans/spring-beans-3.2.xsd
http://www.springframework.org/schema/context
http://www.springframework.org/schema/context/spring-context.xsd>

使用步驟：(需要aop包)

　　1.先引入context名稱空間

　　2.開啟注解掃描

　　　<context:component-scan base -pase-package="xxx.xxx.xxx"></context:cpmponent-scan>

/**
*等價於在xml文件中定義<bean id="userDao" calss="xxx.UserDao">
*/
@Component("userDao")
public class UserDao{
    public void save(){
        System.out.println("正在保存");
    }
}

@Component("userService")//把一個對象加入到IOC容器中
public class userService{
//@Resource(name="userDao"),其中的name就是在UserDao.java中@Component("userDao")
/*等價於
<bean id="userService " calss="xxx.UserService r">
    <property name="userDao" ref="userDao"></property>
</bean>
*/
    @Resource(name="userDao")//屬性的注入，在字段上

　　 private UserDao userDao;
　　 public void setUserDao(UserDao userDao){

this.userDao=userDao } public void save(){ userDao.save(); } }

@Component("userController")
class UserController{

    @Resource(name="userService")
    UserService userService;

    private void setUserService(UserService userService){
        this.userService=userService;
    }

    private void addUser(){
        userService.save();
    }
}

使用注解：

　　把對象加入IOC容器 @Component

　　處理對象依賴關系@Resource

直接使用@Component //在IOC容器中加入的對象的名稱與類名相同，第一個字母小寫，eg:UserController的名字默認為userController

直接使用@Resource //根據類型進行查找，如果找到，直接注入

注意直接使用@Component不知道組件到底是哪個層的，所以Spring還提供了其他類型的注解

持久層用@Repository UserDao

控制層@Controller UserController

業務邏輯層@Service UserService

總結：

　　使用注解，可以簡化配置，且可把對象加入IOC容器，處理依賴關系

　　使用注解可以和xml配置文件結合使用

免責聲明！

本站轉載的文章為個人學習借鑒使用，本站對版權不負任何法律責任。如果侵犯了您的隱私權益，請聯系本站郵箱yoyou2525@163.com刪除。

猜您在找 spring_bean三種裝配方式 spring Bean裝配的幾種方式簡單介紹 spring容器的自動裝配方式總結 spring 自動裝配 bean 有哪些方式？ spring自動裝配bean有哪些方式？ Spring Bean注冊的幾種方式 Spring獲取bean的幾種方式 Spring的幾種注入bean的方式 spring 獲取bean的幾種方式 Spring詳解（六）----Spring Bean的裝配（基於XML的方式）