Spring筆記01_下載_概述_監聽器

時間 2019-12-08

原文原文鏈接

１.Spring介紹

1.1 Spring概述

Spring是一個開源框架，Spring是於2003 年興起的一個輕量級的Java 開發框架，由Rod Johnson 在其著做Expert One-On-One J2EE Development and Design中闡述的部分理念和原型衍生而來。它是爲了解決企業應用開發的複雜性而建立的。Spring使用基本的JavaBean來完成之前只可能由EJB完成的事情。然而，Spring的用途不只限於服務器端的開發。從簡單性、可測試性和鬆耦合的角度而言，任何Java應用均可以從Spring中受益。簡單來講，Spring是一個輕量級的控制反轉（IoC）和麪向切面（AOP）的容器框架。html

1.2 Spring好處

方便解耦，簡化開發java
- Spring就是一個大工廠，專門負責生成Bean，能夠將全部對象建立和依賴關係維護由Spring管理。經過Spring提供的IoC容器，能夠將對象間的依賴關係交由Spring進行控制，避免硬編碼所形成的過分程序耦合。用戶也沒必要再爲單例模式類、屬性文件解析等這些很底層的需求編寫代碼，能夠更專一於上層的應用。
AOP變成的支持mysql
- Spring提供面向切面編程，能夠方便的實現對程序進行權限攔截，運行監控等功能。經過Spring的AOP功能，方便進行面向切面的編程，許多不容易用傳統OOP實現的功能能夠經過AOP輕鬆應付。
聲明式事務的支持web
- 只須要經過配置就能夠完成對事務的管理，而無需手動編程
方便程序的測試spring
- Spring對Junit4支持，能夠經過註解方便的測試Spring程序
方便集成各類優秀框架sql
- Spring不排斥各類優秀的開源框架，其內部提供了對各類優秀框架的支持，如Struts、Hibernate、Mybatis、Quartz等
下降JavaEE API的使用難度數據庫
- 對JavaEE開發中一些難用的API（JDBC、JavaMail、遠程調用等），都提供了封裝，使這些API應用難度大大下降
Java源碼是經典學習範例express
- Spring的源代碼設計精妙、結構清晰、匠心獨用，到處體現着大師對Java設計模式靈活運用以及對Java技術的高深造詣。它的源代碼無心是Java技術的最佳實踐的範例。

1.3 Spring結構體系

Spring框架是一個分層架構，它包含一系列的功能要素並被分爲大約20個模塊。這些模塊分爲Core Container、DataAccess/Integration、Web、AOP、Instrumentation和測試部分。以下圖所示：apache

1.4 在項目中的架構

web層：Struts，SpringMVC
dao層：Hibernate，Mybatis

1.5 程序的耦合和解耦

程序的耦合編程
- 咱們開發種，會寫不少的類，而有些類之間不可避免地產生依賴關係，這種依賴關係稱爲耦合。有些依賴是必須的，有些依賴關係能夠經過優化代碼來解除。好比：

/**
 * 客戶的業務層實現類
 */
public class CustomerServiceImpl implements ICustomerService {
    
    private ICustomerDao customerDao = new CustomerDaoImpl();    
}

上面的代碼表示：業務調用持久層，而且此時業務再依賴持久層的接口和實現類。若是此時沒有持久層實現類，編譯將不能經過。這種依賴關係就是咱們能夠經過優化代碼解決的。
再好比：下面的代碼種，咱們的類依賴MySQL的具體驅動類，若是這獅虎更換了數據庫品牌，咱們須要改源碼來修修改數據庫驅動，這顯然不是咱們想要的。

public class JdbcDemo1 {
    
    /**
     * JDBC操做數據庫的基本入門中存在什麼問題？
     *       致使驅動註冊兩次是個問題，但不是嚴重的。
     *       嚴重的問題：是當前類和mysql的驅動類有很強的依賴關係。
     *                  當咱們沒有驅動類的時候，連編譯都不讓。
     * 那這種依賴關係，就叫作程序的耦合
     * 
     * 咱們在開發中，理想的狀態應該是：
     *       咱們應該盡力達到的：編譯時不依賴，運行時才依賴。
     *      
     * @param args
     * @throws Exception
     */
    public static void main(String[] args) throws Exception {
        //1.註冊驅動
        //DriverManager.registerDriver(new com.mysql.jdbc.Driver());
        Class.forName("com.mysql.jdbc.Driver");
        //2.獲取鏈接
        //3.獲取預處理sql語句對象
        //4.獲取結果集
        //5.遍歷結果集
    }

解決程序耦合的思路
- 在JDBC種是經過反射來註冊驅動的，代碼以下：
```
Clas.forName("com.mysql.jdbc.Driver");
```
- 這時的好處是，咱們類中再也不依賴具體的驅動類，此時就算刪除MySQL的驅動jar包，依然能夠編譯。可是沒有驅動類，因此不能運行。
- 不過，此處也有一個問題，就是咱們反射類對象的全限定類名字符串是在Java類中寫死的，一旦要改仍是徐婭修改源碼。爲了解決這個問題，使用配置文件配置。
工廠模式解耦
- 在實際開發過程總咱們把全部的dao和service和action對象使用配置文件配置起來，當啓動服務器應用加載的時候，經過讀取配置文件，把這些對象建立出來並存起來。在接下來使用的時候，直接拿就行了。
控制反轉---Inversion Of Control
- 上面解耦的思路有兩個問題
  - 建立的對象存儲在哪裏？因爲咱們是不少對象，確定要找個集合來存儲，這時候有Map和List供選擇。究竟是選擇Map仍是List就看咱們有沒有查找的需求。有查找的需求就選Map。因此咱們的答案是：在應用加載時，建立一個Map，用於存放action，service和dao對象。
  - 仍是沒解釋什麼是工廠?工廠就是負責給咱們從容器中獲取指定對象的類。這時候獲取對象的方式發生了改變。之前，咱們在獲取對象的時候，都是採用new的方式，是主動的。

如今，我麼獲取對象的時候，同時跟工廠要，有工廠爲咱們查找或者建立對象。是被動的。這種被動接收的方式獲取對象的思想就是控制反轉，他是Spring框架的核心之一。其做用只有一個：下降計算機程序的耦合。

2. Spring快速入門

使用spring的IOC解決程序耦合

2.1 編寫流程

下載Spring開發包
導入Spring的jar包
配置Spring的核心xml文件
在程序中讀取Spring的配置文件來獲取Bean【Bean其實就是一個new好的對象】

2.2 下載地址

這裏下載4.2.4版本
地址：http://repo.spring.io/release...
官網：spring.io 官網改版後，下載連接須要在對應的GitHub上找

2.3 Spring的核心jar包

spring-core-4.2.4.RELEASE.jar包含Spring框架基本的核心工具類，Spring其餘組件都要使用到這個包裏得嘞，是其餘組件的基本核心。
spring-beans-4.2.4.RELEASE.jar全部應用都要用到的，它包含訪問配置文件、建立和管理bean
以及進行Inversion of Control(IoC) / Dependency Injection(DI)操做相關的全部類。
spring-context-4.2.4.RELEASE.jarSpring提供在基礎IoC功能上的擴展服務，此外還提供許多企業級服務的支持,
如郵件服務、任務調度、JNDI定位、EJB集成、遠程訪問、緩存以及各類視圖層框架的封裝等。
spring-expression-4.2.4.RELEASE.jarSpring表達式語言。
com.springsource.org.apache.commons.logging-1.1.1.jar第三方的主要用於處理日誌。

2.4 Spring入門案例

準備項目須要得jar包
- spring-framework-4.2.4.RELEASE-dist.zip 【Spring的核心包】
- spring-framework-4.2.4.RELEASE-dependencies.zip 【Spring的依賴包】
建立Project，導入Spring的jar包
在src路徑下建立applicationContext.xml文件
- 導入約束
- 把資源交給Spring管理，在xml文件中配置User

<?xml version="1.0" encoding="UTF-8"?>
<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.xsd">

    <!-- 約束的位置在:
        ..\spring-framework-4.2.4.RELEASE\docs\spring-framework-reference\html\xsd-configuration.html
        文檔末尾 -->
    <!-- 
        1. 基本配置：
            bean標籤：指定要建立的實體類
            id屬性：能夠爲任意值 可是在整個配置文件中惟一
            class屬性：要實例化類的全限定名 反射
     -->
    <bean id="user" class="com.itzhouq.domain.User"></bean>

</beans>

測試

package com.itzhouq.domain;

public class User {
    public void run() {
        System.out.println("run");
    }

}

package com.itzhouq.test;

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

import com.itzhouq.domain.User;

public class UserTeset {
    
    @Test
    public void test() {//本身new的對象
        User user = new User();
        user.run();
    }
    
    @Test
    public void test2() {//spring的ioc建立對象
        //加載配置文件  src/classes類路徑
        ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
        //找Spring要對象
        User user = (User) context.getBean("user");
        user.run();
    }
}

3. Spring基於XML的IOC細節

3.1 IOC中bean標籤和管理對象細節

3.1.1 配置文件bean標籤

做用
- 用於配置對象讓Spring來建立的。默認狀況下它調用的是類中的無參構造函數。若是沒有無參構造函數則不能建立成功。
屬性
- id：給對象在容器中提供一個惟一標識，用於獲取對象
- class：指定類的全限定名。用於反射建立對象，默認狀況下調用無參構造函數。
- scope：指定對象的做用範圍。
- init-method：指定類中的初始化方法名稱。
- destroy-method:指定類中銷燬方法名稱。
- import：導入外部配置文件，resource----外部配置文件的地址。

3.1.2 scope屬性：範圍（重點）

<bean id="user" class="cn.itzhouq.domain.User" scope="singleton" ></bean>

singleton: 單實例默認值
若是是單實例,配置文件文件只要一加載就會建立對象放在spring容器 (map<id,對象>)
當全部人過來問spring容器要的時候(getBean),所用人用的都是同一個對象
prototype: 多實例
- 若是是多實例,配置文件加載,不建立對象
- 當每一個人過來getbean的時候,getbean一次建立一次放在容器中
何時用默認值singleton(單實例)? 何時用prototype(多實例)?
- action: prototype
- service/dao: singleton
request：web項目中Spring建立一個Bean對象，將對象存入到request域中
session：web項目中Spring建立一個Bean對象，將對象存入到session域中。
globalSession：web項目中，應用在Portlet環境，若是沒有Portlet環境那麼globalSession至關於session。

3.1.3 bean的做用範圍和生命週期

單例對象：scope="singleton"
- 一個應用只有一個對象的實例。它的做用範圍就是整個引用。
- 生命週期：
  - 對象出生：當應用加載，建立容器時，對象就被建立了。
  - 對象活着：只要容器在，對象一直活着。
  - 對象死亡：當應用卸載，銷燬容器時，對象就被銷燬了。
- 多例對象：scope="prototype"
- 每次訪問對象時，都會從新建立對象實例。
- 生命週期：
  - 對象出生：當使用對象時，建立新的對象實例。
  - 對象活着：只要對象在使用中，就一直活着。
  - 對象死亡：當對象長時間不用時，被java的垃圾回收器回收了。

3.1.4 示例化Bean的三種方式

無參構造方式（最經常使用）

@Test//測試bean的三種建立方式------無參構造方式
    public void test3() {
        //加載配置文件  src/classes類路徑
        ApplicationContext context = new         ClassPathXmlApplicationContext("applicationContext.xml");
        //找Spring要對象
        User user = (User) context.getBean("user");
        user.run();
    }

靜態工廠方式（瞭解）

條件：須要有一個工廠類，在這個工廠類中還須要一個靜態方法

package com.itzhouq.utils;

import com.itzhouq.domain.User;

public class BeanFactory {
    
    public static User createUser() {
        return new User();
    }

}

<!-- 靜態工廠方式 -->
    <bean id="user" class="com.itzhouq.utils.BeanFactory" factory-method ="createUser">

測試

@Test//測試bean的三種建立方式------靜態工廠方式
    public void test4() {
        ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
        User user1 = (User) context.getBean("user");
        System.out.println(user1);//com.itzhouq.domain.User@5f3a4b84
        User user2 = (User) context.getBean("user");
        System.out.println(user2);//com.itzhouq.domain.User@5f3a4b84
    }

實例工廠方式（瞭解）

條件：須要一個工廠類在這個工廠類中須要一個普通方法

package com.itzhouq.utils;

import com.itzhouq.domain.User;

public class BeanFactory {
    
//    public static User createUser() {
//        return new User();
//    }
    
    //普通方法----實例工廠
    public User createUser() {
        return new User();
    }
}

配置文件

<!-- 實例工廠 -->
   <bean id="beanFactory" class="com.itzhouq.utils.BeanFactory"></bean>
   <bean id="user" factory-bean="beanFactory" factory-method="createUser"></bean>

測試

@Test//測試bean的三種建立方式------實例工廠方式
    public void test5() {
        ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
        User user1 = (User) context.getBean("user");
        System.out.println(user1);//com.itzhouq.domain.User@5f3a4b84
        User user2 = (User) context.getBean("user");
        System.out.println(user2);//com.itzhouq.domain.User@5f3a4b84
    }

3.2 加載Spring容器的三種方式

類路徑得到配置文件
文件系統路徑得到配置文件
使用BeanFactory（瞭解）

public class Lession01 {

    @Test
    public void test01(){
        //Spring容器加載有3種方式
        //第一種：ClassPathXmlApplicationContext    ClassPath類路徑加載：指的就是classes路徑
        //最經常使用，Spring的配置文件之後就放在src路徑下
        ApplicationContext context = new ClassPathXmlApplicationContext("beans.xml");

        //第二種方式：文件系統路徑得到配置文件【絕對路徑】
        ApplicationContext context = new FileSystemXmlApplicationContext("E:\\workspaces\\IdeaProject\\Spring-day02-gyf\\src\\beans.xml");

        IUserService user = (IUserService) context.getBean("userService");
        user.add();

        //第三種方式：
        String path = "E:\\workspaces\\IdeaProject\\Spring-day02-gyf\\src\\beans.xml";
        BeanFactory factory = new XmlBeanFactory(new FileSystemResource(path));
        IUserService user1 = (IUserService) factory.getBean("userService");
        user1.add();
    }
}

Spring內部建立對象的原理

1. 解析xml文件，得到類名，id，屬性
2. 經過反射，用類型建立對象
3. 給建立的對象賦值

3.3 BeanFactory和ApplicationContext對比

BeanFactory採用延遲加載，第一次getBean時纔會初始化Bean
ApplicationContext是對BeanFactory擴展，提供了更多功能
- 國際化處理
- 事件傳遞
- Bean自動裝配
- 各類不一樣應用的Context實現
3. 4 Spring的依賴注入DI
DI屬性的依賴注入，是Spring框架核心IoC的具體實現方式。Spring在經過Ioc建立對象的時候，若是這個對象還有屬性，就一併賦值進去，而不用咱們本身去獲取。

入門舉例：

建立一個接口Car

package com.itzhouq.service;

public interface Car {
    public void run();
}

建立實現類CarImpl

package com.itzhouq.serviceImpl;

import com.itzhouq.service.Car;

public class CarImpl implements Car {
    private String name;
    
    public void setName(String name) {
        this.name = name;
    }


    @Override
    public void run() {
        System.out.println(name+"車跑起來了.....");
    }
}

測試

package com.itzhouq.test;
import org.junit.Test;
import com.itzhouq.serviceImpl.CarImpl;
public class CarTest {    
    @Test//本身new對象 本身屬性賦值的方式
    public void test() {
        CarImpl car = new CarImpl();
        car.setName("qq");
        car.run();//qq車跑起來了.....
    }
}

入門舉例2：依賴注入的方式

配置文件：

<!-- DI：屬性的依賴注入 -->
   <bean id="car" class="com.itzhouq.serviceImpl.CarImpl">
           <!-- 
               property：是set屬性的方式
               name：要賦值的屬性名
               value：要賦的值
            -->
            <property name="name" value="蘭博基尼"></property>
   </bean>

測試

@Test   //Spring的IOC
    public void test2() {
        ApplicationContext context = new ClassPathXmlApplicationContext("ApplicationContext.xml");
        Car car = (Car)context.getBean("car");
        //把這個對象的屬性也在建立的時候給順便賦值了-----DI
        car.run();//蘭博基尼車跑起來了.....
    }

依賴注入的方式
- 構造函數注入（瞭解）
- set方法注入（掌握）
- 使用p名稱空間注入數據（本質仍是調用set方法）（瞭解）
- 注入集合屬性

3.4.1 構造器注入方式

條件：須要有有參構造方法

給CarImpl設置有參構造

package com.itzhouq.serviceImpl;

import com.itzhouq.service.Car;

public class CarImpl implements Car {
    private String name;
    private double price;
    public void setName(String name) {
        this.name = name;
    }
    public double getPrice() {
        return price;
    }
    public void setPrice(double price) {
        this.price = price;
    }
    public String getName() {
        return name;
    }
    public CarImpl() {}
    //有參的構造方法----DI的構造器注入方式
    public CarImpl(String name, double price) {
        super();
        this.name = name;
        this.price = price;
    }
    @Override
    public void run() {
        System.out.println("價值"+price+"的"+name+"車跑起來了.....");
    }
}

配置文件

<!-- DI的注入方式,構造器注入方式 
           name:要賦值的屬性名
           value：要賦的值（針對的是基本數據類型和String類型）
           ref針對的是對象類型
   -->
   <bean id="car" class="com.itzhouq.serviceImpl.CarImpl">
           <constructor-arg name="name" value="BMW"></constructor-arg>
           <constructor-arg name="price" value="1000000"></constructor-arg>
   </bean>

測試

@Test   //Spring的DI注入方式----構造器的注入方式（瞭解）
    public void test3() {
        ApplicationContext context = new ClassPathXmlApplicationContext("ApplicationContext.xml");
        Car car = (Car)context.getBean("car");
        car.run();//價值1000000.0的BMW車跑起來了.....
    }

3.4.2 set方式注入

寫一個Person接口

package com.itzhouq.service;

public interface Person {
}

PersonImpl實現接口Person,設置set方法

package com.itzhouq.serviceImpl;

import com.itzhouq.service.Car;
import com.itzhouq.service.Person;

public class PersonImpl implements Person {
    private String name;
    private Car car;
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public Car getCar() {
        return car;
    }
    public void setCar(Car car) {
        this.car = car;
    }
    @Override
    public String toString() {
        return "PersonImpl [name=" + name + ", car=" + car + "]";
    }
}

配置文件

<bean id="car" class="com.itzhouq.serviceImpl.CarImpl">
           <constructor-arg name="name" value="BMW"></constructor-arg>
           <constructor-arg name="price" value="1000000"></constructor-arg>
   </bean>
   
   <!-- DI的注入方式,set注入方式 
           name:要賦值的屬性名
           value：要賦的值（針對的是基本數據類型和String類型）
           ref針對的是對象類型,指的是Spring中bean的id名
   -->
   <bean id="person" class="com.itzhouq.serviceImpl.PersonImpl">
           <property name="name" value="jack"></property>
           <property name="car" ref="car"></property>
   </bean>

測試

@Test   //Spring的DI注入方式----set的注入方式（瞭解）
    public void test4() {
        ApplicationContext context = new ClassPathXmlApplicationContext("ApplicationContext.xml");
        Person person = (Person) context.getBean("person");
        System.out.println(person);
        //PersonImpl [name=jack, car=CarImpl [name=BMW, price=1000000.0]]
    }

3.4.3 使用p名稱空間注入數據(知道就OK)

此種方式是經過在xml中導入p名稱空間，使用p:propertyName來注入數據，它的本質仍然是調用類中的set方法實現注入功能。

配置文件

<beans xmlns="http://www.springframework.org/schema/beans"
        xmlns:p="http://www.springframework.org/schema/p"
         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.xsd">
                               
    <bean id="customerService" 
          class="com.itheima.service.impl.CustomerServiceImpl4"
          p:name="test" p:age="21" p:birthday-ref="now"/>
</beans>

3.4.4 注入集合屬性

顧名思義，就是給類中的集合成員傳值，它用的也是set方法注入的方式，只不過變量的數據類型都是集合。咱們這裏介紹注入數組，List,Set,Map,Properties。

建立一個類CollBean，設置set方法

package com.itzhouq.domain;

import java.util.Arrays;
import java.util.List;
import java.util.Map;
import java.util.Properties;


public class CollBean {
    private String[] ss;
    private List ll;
    private Map mm;
    private Properties properties;
    public String[] getSs() {
        return ss;
    }
    public void setSs(String[] ss) {
        this.ss = ss;
    }
    public List getLl() {
        return ll;
    }
    public void setLl(List ll) {
        this.ll = ll;
    }
    public Map getMm() {
        return mm;
    }
    public void setMm(Map mm) {
        this.mm = mm;
    }
    public Properties getProperties() {
        return properties;
    }
    public void setProperties(Properties properties) {
        this.properties = properties;
    }
    @Override
    public String toString() {
        return "CollBean [ss=" + Arrays.toString(ss) + ", ll=" + ll + ", mm=" + mm + ", properties=" + properties + "]";
    }

}

配置文件

<bean id="car" class="com.itzhouq.serviceImpl.CarImpl">
           <constructor-arg name="name" value="BMW"></constructor-arg>
           <constructor-arg name="price" value="1000000"></constructor-arg>
   </bean>
   <!-- DI複雜屬性注入 -->
   <bean id="collBean" class="com.itzhouq.domain.CollBean">
           <property name="ss">
               <!-- 數組類型 -->
               <list>
                   <value>aaa</value>
                   <value>bbb</value>
                   <value>ccc</value>
               </list>
           </property>
           <property name="ll">
               <!-- 集合類型 -->
               <list>
                   <value>111</value>
                   <value>222</value>
                   <ref bean="car"></ref>
               </list>
           </property>
           <property name="mm">
               <!-- map類型 -->
               <map>
                   <entry key="k1" value="AAA"></entry>
                   <entry key="k2" value="BBB"></entry>
                   <entry key="k3" value-ref="car"></entry>
               </map>
           </property>
           <property name="properties">
               <!-- properties -->
               <props>
                   <prop key="hibernate.username">root</prop>
                   <prop key="hibernate.password">1234</prop>
               </props>
           </property>
   </bean>

測試

package com.itzhouq.test;
      
      import org.junit.Test;
      import org.springframework.context.ApplicationContext;
      import org.springframework.context.support.ClassPathXmlApplicationContext;
      
      import com.itzhouq.domain.CollBean;
      
      public class CollBeanTest {
          @Test
          public void test() {
              ApplicationContext context = new ClassPathXmlApplicationContext("ApplicationContext.xml");
              CollBean cb = (CollBean) context.getBean("collBean");
              System.out.println(cb);
              /*
               * CollBean [ss=[aaa, bbb, ccc], 
               * ll=[111, 222, CarImpl [name=BMW, price=1000000.0]],
               *  mm={k1=AAA, k2=BBB, k3=CarImpl [name=BMW, price=1000000.0]}, 
               *  properties={hibernate.password=1234, hibernate.username=root}]
               */
          }
      }

4.使用案例

需求分析：從service層調用dao層，將數據存儲到數據庫，存儲數據的過程使用syso模擬一下就能夠。
建立工程，導入須要的jar包，建包以下：

建立dao層和dao實現層

package com.itzhouq.dao;

public interface UserDao {
    void save();
}

package com.itzhouq.daoImpl;

import com.itzhouq.dao.UserDao;

public class UserDaoImpl implements UserDao{

    @Override
    public void save() {
        System.out.println("操做數據庫，保存用戶的數據");    
    }
}

建立Service層和實現層

package com.itzhouq.service;

public interface UserService {
    public void save();
}

package com.itzhouq.serviceImpl;

import com.itzhouq.dao.UserDao;
import com.itzhouq.daoImpl.UserDaoImpl;
import com.itzhouq.service.UserService;

public class UserServiceImpl implements UserService {
    private String name;
    private UserDao userDao;
    public void setUserDao(UserDao userDao) {
        this.userDao = userDao;
    }
    public void setName(String name) {
        this.name = name;
    }

    @Override
    public void save() {
        System.out.println(name);
        //調用dao
        userDao.save();
    }
}

給UserDaoImpl一個UserDao屬性

配置文件

<?xml version="1.0" encoding="UTF-8"?>
<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.xsd">
    <!-- 建立dao -->
    <bean id="userDao" class="com.itzhouq.daoImpl.UserDaoImpl"></bean>
    
    <!-- 建立service -->
    <bean id="UserService" class="com.itzhouq.serviceImpl.UserServiceImpl">
        <property name="name" value="要開始訪問dao了"></property>
        <property name="userDao" ref="userDao"></property>
    </bean>
</beans>

測試

@Test    //使用Spring的IOC+DI來實現對象的建立和賦值
    public void test() {
        ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
        UserService userService = (UserService) context.getBean("UserService");
        userService.save();
        //要開始訪問dao了
        //操做數據庫，保存用戶的數據
    }