spring IOC基本配置（xml配置和注解配置）
生活随笔
收集整理的這篇文章主要介紹了
spring IOC基本配置（xml配置和注解配置）
小編覺得挺不錯的,現在分享給大家,幫大家做個參考.
目錄
- Spring IOC
- IOC是什么
- IOC可以做什么
- 依賴注入
- IOC和DI
- IOC容器
- Bean
- 配置IOC容器
- spring ioc 依賴
- XML配置
- 實例化容器
- 使用容器
- xml配置詳解
- spring對bean的管理
- 1、創建bean的三種方式
- 2、bean對象的作用范圍
- 3、bean對象的生命周期
- 構造函數依賴注入
- Setter方法依賴注入
- 注解配置
- 使用xml和注解配置
- xml配置
- @Component、@Controller、@Service、@Repository
- 用于注入數據的注解
- @Autowired
- @Qualifier
- @Resource
- 關于@Autowired、@Qualifier、@Resource
- @Value
- 用于指定作用范圍的注解 @Scope
- 與生命周期相關的注解 @PreDestroy、@PostConstruct
- 使用注解配置
- 使用@Configuration
- @ComponentScan
- @Bean
- @Import
- @PropertySource
- 注解配置案例
- Maven 依賴
- domain
- 配置類
- 主配置類
- 子配置類
- jdbc.properties
- 持久層
- IAccountDao
- IAccountDaoimpl
- 業務層
- IAccountService
- IAccountServiceimpl
- 測試類
Spring IOC
IOC是什么
IOC是 Inversion of Control 的縮寫，即控制反轉。
- 上層模塊不應該依賴于下層模塊，它們共同依賴于一個抽象
- 抽象不能依賴于具體實現，具體實現依賴于抽象
IoC 不是什么技術，而是一種設計思想。在 Java 開發中，IoC 意味著將你設計好的對象交給容器控制，而不是傳統的在你的對象內部直接控制。如何理解 Ioc 呢？理解 Ioc 的關鍵是要明確“誰控制誰，控制什么，為何是反轉（有反轉就應該有正轉了），哪些方面反轉了”，那我們來深入分析一下：
誰控制誰，控制什么：傳統 JavaSE 程序設計，我們直接在對象內部通過 new 進行創建對象，是程序主動去創建依賴對象；而 IoC 是有專門一個容器來創建這些對象，即由 IoC 容器來控制對象的創建；誰控制誰？當然是 IoC 容器控制了對象；控制什么？那就是主要控制了外部資源獲取（不只是對象包括比如文件等）。
為何是反轉，哪些方面反轉了：有反轉就有正轉，傳統應用程序是由我們自己在對象中主動控制去直接獲取依賴對象，也就是正轉；而反轉則是由容器來幫忙創建及注入依賴對象；為何是反轉？因為由容器幫我們查找及注入依賴對象，對象只是被動的接受依賴對象，所以是反轉；哪些方面反轉了？依賴對象的獲取被反轉了。
----轉載自github的一篇博客。
未使用IOC容器前
使用IOC容器后
IOC可以做什么
IoC 不是一種技術，只是一種思想，一個重要的面向對象編程的法則，它能指導我們如何設計出松耦合、更優良的程序。傳統應用程序都是由我們在類內部主動創建依賴對象，從而導致類與類之間高耦合，難于測試；有了 IoC 容器后，把創建和查找依賴對象的控制權交給了容器，由容器進行注入組合對象，所以對象與對象之間是松散耦合，這樣也方便測試，利于功能復用，更重要的是使得程序的整個體系結構變得非常靈活。
其實 IoC 對編程帶來的最大改變不是從代碼上，而是從思想上，發生了“主從換位”的變化。應用程序原本是老大，要獲取什么資源都是主動出擊，但是在 IoC/DI 思想中，應用程序就變成被動的了，被動的等待 IoC 容器來創建并注入它所需要的資源了。
IoC 很好的體現了面向對象設計法則之一—— 好萊塢法則：“別找我們，我們找你”；即由 IoC 容器幫對象找相應的依賴對象并注入，而不是由對象主動去找。
----轉載自github的一篇博客。
依賴注入
DI，是 Dependency Injection 的縮寫，即依賴注入。
依賴注入是 IoC 的最常見形式。
容器全權負責的組件的裝配，它會把符合依賴關系的對象通過 JavaBean 屬性或者構造函數傳遞給需要的對象。
DI 是組件之間依賴關系由容器在運行期決定，形象的說，即由容器動態的將某個依賴關系注入到組件之中。依賴注入的目的并非為軟件系統帶來更多功能，而是為了提升組件重用的頻率，并為系統搭建一個靈活、可擴展的平臺。通過依賴注入機制，我們只需要通過簡單的配置，而無需任何代碼就可指定目標需要的資源，完成自身的業務邏輯，而不需要關心具體的資源來自何處，由誰實現。
理解 DI 的關鍵是：“誰依賴誰，為什么需要依賴，誰注入誰，注入了什么”，那我們來深入分析一下：
誰依賴于誰：當然是應用程序依賴于 IoC 容器；
為什么需要依賴：應用程序需要 IoC 容器來提供對象需要的外部資源；
誰注入誰：很明顯是 IoC 容器注入應用程序某個對象，應用程序依賴的對象；
注入了什么：就是注入某個對象所需要的外部資源（包括對象、資源、常量數據）。
IOC和DI
其實它們是同一個概念的不同角度描述，由于控制反轉概念比較含糊（可能只是理解為容器控制對象這一個層面，很難讓人想到誰來維護對象關系），所以 2004 年大師級人物 Martin Fowler 又給出了一個新的名字：“依賴注入”，相對 IoC 而言，“依賴注入”明確描述了“被注入對象依賴 IoC 容器配置依賴對象”。
IOC容器
其實它們是同一個概念的不同角度描述，由于控制反轉概念比較含糊（可能只是理解為容器控制對象這一個層面，很難讓人想到誰來維護對象關系），所以 2004 年大師級人物 Martin Fowler 又給出了一個新的名字：“依賴注入”，相對 IoC 而言，“依賴注入”明確描述了“被注入對象依賴 IoC 容器配置依賴對象”。
Bean
JavaBean 是一種 JAVA 語言寫成的可重用組件。為寫成 JavaBean，類必須是具體的和公共的，并且具有無參數的構造器。JavaBean 對外部通過提供 getter / setter 方法來訪問其成員。
由 IoC 容器管理的那些組成你應用程序的對象我們就叫它 Bean。Bean 就是由 Spring 容器初始化、裝配及管理的對象，除此之外，bean 就與應用程序中的其他對象沒有什么區別了。那 IoC 怎樣確定如何實例化 Bean、管理 Bean 之間的依賴關系以及管理 Bean 呢？這就需要配置元數據，在 Spring 中由 BeanDefinition 代表，后邊會詳細介紹，配置元數據指定如何實例化 Bean、如何組裝 Bean 等。
配置IOC容器
IoC 容器的配置有三種方式：
- 基于 xml 配置
- 基于注解配置
- 基于 Java 配置
spring ioc 依賴
首先我們先導入maven的spring ioc依賴
<dependencies><dependency><groupId>org.springframework</groupId><artifactId>spring-context</artifactId><version>5.2.0.RELEASE</version></dependency> </dependencies>XML配置
首先創建一個spring ioc 的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"xsi:schemaLocation="http://www.springframework.org/schema/beanshttps://www.springframework.org/schema/beans/spring-beans.xsd http://www.springframework.org/schema/context https://www.springframework.org/schema/context/spring-context.xsd"> <bean id="UserService" class="com.service.Impl.IUserServiceimpl"> </bean><import resource="bean2.xml" /> </beans>標簽說明：
- <beans> 是 Spring 配置文件的根節點。
- <bean>用來定義一個 JavaBean。id 屬性是它的標識，在文件中必須唯一；class 屬性是它關聯的類。
- <import /> 用來導入其他配置文件的 Bean 定義。這是為了加載多個配置文件。
實例化容器
核心容器的兩個接口
- ApplicationContext： 單例對象適用
它在構建核心容器時，創建對象采取的策略是采用立即加載的方式。也就是說，只要一讀取完配置文件馬上就創建配置文件中配置的對象 - BeanFactory： 多例對象適用
它在構建核心容器時，創建對象采取的策略是采用延時加載的方式。也就是說，只有通過id獲取對象時，才真正的創建對象
實例化容器的過程： 定位資源（XML 配置文件） 讀取配置信息(Resource) 轉化為 Spring 可識別的數據形式（BeanDefinition）。
ApplicationContext context =new ClassPathXmlApplicationContext(new String[] {"bean1.xml", "bean2.xml"});組合 xml 配置文件 配置的 Bean 功能各不相同，都放在一個 xml 文件中，不便管理。 Java 設計模式講究職責單一原則。配置其實也是如此，功能不同的 JavaBean 應該被組織在不同的 xml 文件中。然后使用 import 標簽把它們統一導入。
ApplicationContext是一個接口 有常用的三個實現類
- 1、ClassPathXmlApplicationContext
- 它可以加載類路徑下的配置文件，要求配置文件必須要在類路徑下。
- ApplicationContext context = new ClassPathXmlApplicationContext(new String[] {"bean1.xml", "bean2.xml"});
- 2、FileSystemXmlApplicationContext
- 它可以加載磁盤任意路徑下的配置文件(前提是必須有訪問權限)
- 3、AnnotationConfigApplicationContext
- 它用于讀取注解創建容器的。
- new AnnotationConfigApplicationContext(Class<?> ... config);
- ApplicationContext applicationContext = new AnnotationConfigApplicationContext(SpringConfiguration.class);
使用容器
使用容器的方式就是通過getBean獲取 IoC 容器中的 JavaBean。
第一種 getBean(String id)
第二種 getBean(String id, Class<?> object)
xml配置詳解
spring對bean的管理
1、創建bean的三種方式
-
使用默認構造函數(無參)創建對象
- 在使用spring配置文件中使用bean標簽時，配以id和class屬性之后并且沒有其他屬性和標簽時，采用的就是默認構造函數創建bean對象，此時如果類中沒有默認構造函數，則對象無法創建。
-
使用普通工廠中的方法創建對象（使用某個類中的方法創建對象，并存入spring容器）
- id為需要創建的對象的id（需要為目標對象配bean），factory-bean屬性為工廠類的id（先給工廠類配bean），factory-method屬性為工廠類創建目標對象的方法（該方法不能為static）
-
使用普通工廠中的靜態(static)方法創建對象（使用某個類中的靜態(static)方法創建對象，并存入spring容器）
- class屬性為工廠的全限定類名，這也代表著bean創建的id對應的是工廠類, 但是設置factory-method屬性為工廠類創建目標對象的靜態(static)方法,這樣就會默認調用該方法，返回的就是目標對象。
使用默認構造函數(無參)創建對象
<bean id="UserService" class="com.service.Impl.IUserServiceimpl"> </bean>使用普通工廠中的方法創建對象
<bean id="instanceFactory" class="com.factory.InstanceFactory"></bean><bean id="IUserService" factory-bean="instanceFactory" factory-method="getIUserSevice" ></bean>使用普通工廠中的靜態(static)方法創建對象
<bean id="IUserService" class="com.factory.staticFactory" factory-method="getIUserSevice"></bean>2、bean對象的作用范圍
默認情況下 bean對象只創建一次————————單例對象。我們可以通過bean標簽的scope屬性設置bean對象的作用范圍。
scope屬性：
- 作用：用于指定bean的作用范圍
- 取值：
- singleton：單例的（默認值）
- prototype：多例的
- request：作用于web應用的請求范圍
- session：作用于web應用的會話范圍
- global-session：作用于集群環境的會話范圍（全局會話范圍）。當不是集群環境時，與session等同
3、bean對象的生命周期
1、單例對象：
- 出生：當容器創建時對象出生
- 活著：只要容器沒有銷毀，對象一直活著
- 死亡：當容器銷毀，對象跟著死亡
- 總結：單例對象的生命周期與容器相同
2、多例對象：
- 出生：當我們使用對象時spring框架為我們創建
- 活著：對象只要在使用過程中就一直活著
- 死亡：當對象長時間未使用且沒有其他對象引用時，java垃圾回收機制會自動回收對象
我們可以借助bean標簽的init-method屬性調用初始化方法和destroy-method調用銷毀方法
//init 和 destroy 是類IUserServiceimpl 定義的方法 <bean id="IUserService" class="com.service.Impl.IUserServiceimpl" scope="singleton" init-method="init" destroy-method="destroy"></bean>構造函數依賴注入
- 使用的標簽：<constructor-arg></constructor-arg>
- 標簽出現的位置：bean標簽內部
- 標簽的屬性：
- name：用于指定給構造函數中指定名稱的參數賦值
- index：用于指定需要注入的數據給構造函數中指定索引位置的參數賦值
- type：用于指定需要注入的數據類型，該數據類型也是構造函數中某個或者某些參數的類型
- value:用于指定基本類型和String類型的數據
- ref：用于指定其他bean類型數據。它指的就是在Spring的ioc核心容器中出現過的bean對象
對應的構造函數
public IUserServiceimpl(String name, Date birthday, Integer age) {this.name = name;this.birthday = birthday;this.age = age;}Setter方法依賴注入
首先該對象得Setter方法
- 使用的標簽：property
- 標簽出現的位置：bean標簽內部
- 標簽的屬性：
- name：用于指定給set方法名稱
- value:用于指定基本類型和String類型的數據
- ref：用于指定其他bean類型數據。它指的就是在Spring的ioc核心容器中出現過的bean對象
復雜類型的注入或者集合結構類型的注入
- 使用的標簽：property
- 標簽出現的位置：bean標簽內部
- 用于給list結構集合注入的標簽：
- <array> <list> <set>
- 注意，結構相同標簽可以互換
- 用于給map結構集合注入的標簽
- <map> <props>
- 注意，結構相同標簽可以互換
對應的bean類
public class fuzajiegou {private String[] myArr;private List myList;private Set mySet;private Properties myPro;private Map<String,String> myMap;public void setMyArr(String[] myArr) {this.myArr = myArr;}public void setMyList(List myList) {this.myList = myList;}public void setMySet(Set mySet) {this.mySet = mySet;}public void setMyPro(Properties myPro) {this.myPro = myPro;}public void setMyMap(Map<String, String> myMap) {this.myMap = myMap;} } public static void main(String[] args) {ApplicationContext applicationContext = new ClassPathXmlApplicationContext("bean.xml");final fuzajiegou fuzajiegou = applicationContext.getBean("fuzajiegou", fuzajiegou.class);System.out.println(fuzajiegou);}注解配置
使用xml和注解配置
xml配置
Spring 默認是不啟用注解的。如果想使用注解，需要先在 xml 中啟動注解。 啟動方式：在 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/beanshttps://www.springframework.org/schema/beans/spring-beans.xsd http://www.springframework.org/schema/context https://www.springframework.org/schema/context/spring-context.xsd"><context:component-scan base-package="com"/></beans>標簽說明：
- <context:component-scan base-package="com"/> 標簽
- 屬性base-package 表示掃描的位置
@Component、@Controller、@Service、@Repository
@Component 注解
- 作用：用于將當前類對象存入spring容器
- 屬性：
- value：用于指定<bean>的id。當我們不寫時默認為當前類名，且首字母小寫
@Controller、@Service、@Repository 注解
- 以上這三種的作用和屬性與@Component一樣,用這三種注解使三層結構對象更清晰。
- @Controller 表示表現層
- @Service 表示業務層
- @Repository 表示持久層
用于注入數據的注解
他們的作用就和xml配置文件中的bean標簽中寫一個<property></property>標簽的作用是一樣的
@Autowired
@Autowired
- 作用：自動按照類型注入。只需要容器中有唯一的一個bean對象類型和要注入的變量匹配，就可以注入成功。 如果ioc容器中沒有任何bean的類型與要注入的變量類型匹配，則報錯。
- 細節：
- 如果ioc容器中有多個類型匹配時：先按照變量類型找出所有，然后將變量名稱作為id進行查找對應的對象/值。
@Qualifier
- 作用：在按照類型注入的基礎(@Autowired)上再按照名稱注入。
- 細節：
- 它在給類成員注入時不能單獨使用。
- 但是在給方法參數注入時可以單獨使用。
- 屬性：
- value：用于指定注入bean的id。
@Resource
- 作用：直接按照bean的id注入。它可以單獨使用。
- 屬性：
- name：用于指定bean的id
關于@Autowired、@Qualifier、@Resource
以上三種注解(@Autowired、@Qualifier、@Resource)都只能注入其他bean類型的數據，而基本類型和String類型無法使用上述三種注解實現
@Value
- 作用：用于注入基本類型和String類型的數據
- 屬性：
- value：用于指定數據的值。它可以使用spring中的el表達式（spEL）。spEl的寫法：${表達式}
用于指定作用范圍的注解 @Scope
他們的作用就和bean標簽中使用scope屬性實現的功能一致。
@Scope
- 作用：用于指定bean的作用范圍
- 屬性：
- value：指定范圍的取值。常用取值：singleton（單例），prototype（多例）…
與生命周期相關的注解 @PreDestroy、@PostConstruct
他們的作用就和bean標簽中使用scope屬性實現的功能一致。
@PreDestroy
- 作用：用于指定銷毀方法
@PostConstruct - 作用：用于指定初始化方法
使用注解配置
首先使用注解配置需要解決xml配置文件中注解對<context:component-scan base-package="com"/>的依賴
我們可以使用@ComponentScan注解來代替<context:component-scan base-package="com"/>
使用@Configuration
@Configuration
- 作用：指定當前類是一個配置類
- 細節：當該配置類作為AnnotationConfigApplicationContext對象創建的參數時，該注解可以不寫。
@ComponentScan
@ComponentScan
- 作用：用于通過注解指定spring在創建容器時要掃描的包
- 屬性：
- basePackages：它和value的作用是一致的，都是用于指定創建容器時需要掃描的包,我們使用此注解就等同于在xml配置了：<context:component-scan base-package=""/>.
- value：與basePackages一樣
- 以上兩個屬性的值都是一個String[]數組。數組的每個值表示要掃描的包名。
- 細節：
- 被掃描的包中的類需要被掃描到的話需要加上 @Configuration 注解。
@Bean
- 作用：用于將當前方法的返回值作為bean對象存入spring的IOC容器中。
- 屬性：
- name：用于指定bean的id。當不寫name時，默認值為當前方法的名稱。
- 細節：
- 當我們使用注解配置方法時，如果方法有參數，spring框架會去容器中查找有沒有可用的bean對象。 查找的方式和 @Autowired注解的作用是一致的。使用@Bean注解默認是單例的，需要加個@Scope("prototype")指明為多例對象
@Import
- 作用：用于導入其他的配置類。
- 屬性：
- Class []value：該數組的值就是需要引入的其他配置類的字節碼文件。
- 細節：
- 當類被其他類用@Import 注解引入時，該類就不需要用 @Configuration來指明是配置類.相當于，使用@Import的配置類為父配置類，引入的類就是子配置類.在使用AnnotationConfigApplicationContext對象創建IOC容器時只需要引入父配置類即可。
@PropertySource
- 作用：用于指定Properties文件的位置
- 屬性：
- String []value：指定文件的路徑和名稱。關鍵詞：classpath 表示類路徑下。例如 @PropertySource("classpath:jdbc.properties")
注解配置案例
這是一個單表CRUD的案例。
項目結構
Maven 依賴
<dependencies><dependency><groupId>org.springframework</groupId><artifactId>spring-context</artifactId><version>5.2.5.RELEASE</version></dependency><dependency><groupId>mysql</groupId><artifactId>mysql-connector-java</artifactId><version>8.0.14</version></dependency><dependency><groupId>commons-dbutils</groupId><artifactId>commons-dbutils</artifactId><version>1.6</version></dependency><dependency><groupId>c3p0</groupId><artifactId>c3p0</artifactId><version>0.9.1</version></dependency><dependency><groupId>junit</groupId><artifactId>junit</artifactId><version>4.13</version><scope>test</scope></dependency></dependencies>domain
package com.domain;public class Account {private Integer id;private String name;private double money;public Account() {}public Account(String name, double money) {this.name = name;this.money = money;}@Overridepublic String toString() {return "Account{" +"id=" + id +", name='" + name + '\'' +", money=" + money +'}';}public Integer getId() {return id;}public void setId(Integer id) {this.id = id;}public String getName() {return name;}public void setName(String name) {this.name = name;}public double getMoney() {return money;}public void setMoney(double money) {this.money = money;} }配置類
主配置類
package com.config;import com.mchange.v2.c3p0.ComboPooledDataSource; import org.apache.commons.dbutils.QueryRunner; import org.springframework.beans.factory.annotation.Configurable; import org.springframework.context.annotation.*;import javax.sql.DataSource; @Configuration @ComponentScan(basePackages = {"com.Dao","com.service"}) @Import({jdbcConfig.class}) @PropertySource({"classpath:jdbc.properties"}) public class SpringConfiguration {}子配置類
package com.config;import com.mchange.v2.c3p0.ComboPooledDataSource; import org.apache.commons.dbutils.QueryRunner; import org.springframework.beans.factory.annotation.Value; import org.springframework.context.annotation.Bean; import org.springframework.context.annotation.Scope;import javax.sql.DataSource;public class jdbcConfig {@Value("${jdbc.driver}")private String driver;@Value("${jdbc.jdbcUrl}")private String jdbcUrl;@Value("${jdbc.username}")private String username;@Value("${jdbc.password}")private String password;/*** dbUtils* @param dataSource* @return*/@Bean(name = "runner")@Scope("prototype")public QueryRunner createQueryRunner(DataSource dataSource) {return new QueryRunner(dataSource);}/*** 配置數據源* @return*/@Bean(name = "dataSource")public DataSource createDataSource() {try {ComboPooledDataSource ds = new ComboPooledDataSource();ds.setDriverClass(driver);ds.setJdbcUrl(jdbcUrl);ds.setUser(username);ds.setPassword(password);return ds;} catch (Exception e) {throw new RuntimeException(e);}}}jdbc.properties
jdbc.driver=com.mysql.cj.jdbc.Driver jdbc.jdbcUrl=jdbc:mysql://localhost:3306/zlf?serverTimezone=UTC jdbc.username=root jdbc.password=feng10.10持久層
IAccountDao
package com.Dao;import com.domain.Account;import java.util.List;/***賬戶的持久層接口**/ public interface IAccountDao {/*** 查詢所有* @return*/List<Account> selAll();/*** 查詢一個* @param id* @return*/Account findAccountbyid(int id);/*** 保存* @param account*/void saveAccount(Account account);/***更新* @param account*/void updateAccount(Account account);/*** 刪除* @param id*/void deleteAccount(int id) throws Exception; }IAccountDaoimpl
package com.Dao.Impl;import com.Dao.IAccountDao; import com.domain.Account; import org.apache.commons.dbutils.QueryRunner; import org.apache.commons.dbutils.handlers.BeanHandler; import org.apache.commons.dbutils.handlers.BeanListHandler; import org.springframework.beans.factory.annotation.Autowired; import org.springframework.stereotype.Repository;import java.util.List;/*** 賬戶的持久層實現類*/ @Repository("IAccountDao") public class IAccountDaoimpl implements IAccountDao {@Autowiredprivate QueryRunner runner;public void setRunner(QueryRunner runner) {this.runner = runner;}public List<Account> selAll() {try{return runner.query("select *from account",new BeanListHandler<Account>(Account.class));}catch (Exception e){throw new RuntimeException(e);}}public Account findAccountbyid(int id) {try{return runner.query("select *from account where id=?",new BeanHandler<Account>(Account.class),id);}catch (Exception e){throw new RuntimeException(e);}}public void saveAccount(Account account) {try{runner.update("insert into account(name,money) values(?,?)" ,account.getName(),account.getMoney());}catch (Exception e){throw new RuntimeException(e);}}public void updateAccount(Account account) {try{runner.update("update account set name=? ,money=? where id=?" ,account.getName(),account.getMoney(),account.getId());}catch (Exception e){throw new RuntimeException(e);}}public void deleteAccount(int id) {try {runner.update("delete from account where id=?",id);}catch (Exception e){throw new RuntimeException(e);}} }業務層
IAccountService
package com.service;import com.domain.Account;import java.util.List;/*** 賬戶的業務層接口*/ public interface IAccountService {/*** 查詢所有* @return*/List<Account> selAll();/*** 查詢一個* @param id* @return*/Account findAccountbyid(int id);/*** 保存* @param account*/void saveAccount(Account account);/***更新* @param account*/void updateAccount(Account account);/*** 刪除* @param id*/void deleteAccount(int id) throws Exception;}IAccountServiceimpl
package com.service.Impl;import com.Dao.IAccountDao; import com.Dao.Impl.IAccountDaoimpl; import com.domain.Account; import com.service.IAccountService; import org.springframework.beans.factory.annotation.Autowired; import org.springframework.stereotype.Service;import java.util.List; @Service("IAccountService") public class IAccountServiceimpl implements IAccountService {@Autowiredprivate IAccountDao iAccountDao;public List<Account> selAll() {return iAccountDao.selAll();}public Account findAccountbyid(int id) {return iAccountDao.findAccountbyid(id);}public void saveAccount(Account account) {iAccountDao.saveAccount(account);}public void updateAccount(Account account) {iAccountDao.updateAccount(account);}public void deleteAccount(int id) throws Exception {iAccountDao.deleteAccount(id);}public void setiAccountDao(IAccountDaoimpl iAccountDao) {this.iAccountDao=iAccountDao;} }測試類
package com.test;import com.config.SpringConfiguration; import com.domain.Account; import com.mchange.v2.c3p0.ComboPooledDataSource; import com.service.IAccountService; import org.apache.commons.dbutils.QueryRunner; import org.apache.commons.dbutils.handlers.BeanListHandler; import org.junit.Before; import org.junit.Test; import org.springframework.context.ApplicationContext; import org.springframework.context.annotation.AnnotationConfigApplicationContext; import org.springframework.context.support.ClassPathXmlApplicationContext;import javax.sql.DataSource; import java.util.List;public class accountServiceTest {IAccountService iAccountService = null;@Beforepublic void init() throws Exception {final ApplicationContext applicationContext = new AnnotationConfigApplicationContext(SpringConfiguration.class);iAccountService = applicationContext.getBean("IAccountService", IAccountService.class);}/*** 查詢所有*/@Testpublic void findAll() {System.out.println(iAccountService.selAll());}/*** 查詢一位*/@Testpublic void findOne() {System.out.println(iAccountService.findAccountbyid(2));}/*** 保存*/@Testpublic void TestSave() {iAccountService.saveAccount(new Account("小明", 1002.5));}/*** 更新*/@Testpublic void TestUpadata() {final Account account = iAccountService.findAccountbyid(4);account.setMoney(100002.5);iAccountService.updateAccount(account);}/*** 刪除** @throws Exception*/@Testpublic void Testdalete() throws Exception {iAccountService.deleteAccount(4);}}總結
以上是生活随笔為你收集整理的spring IOC基本配置（xml配置和注解配置）的全部內容，希望文章能夠幫你解決所遇到的問題。
- 上一篇： java字符流和字节流的区别_java字
- 下一篇： php充值注入,PHP注入一路小跑